packages feed

sbv 8.17 → 9.0

raw patch · 219 files changed

+36687/−35880 lines, 219 filesdep +tasty-benchdep −Globdep −bench-showdep −doctestdep ~asyncdep ~base

Dependencies added: tasty-bench

Dependencies removed: Glob, bench-show, doctest, gauge, silently

Dependency ranges changed: async, base

Files

CHANGES.md view
@@ -1,8 +1,60 @@ * Hackage: <http://hackage.haskell.org/package/sbv> * GitHub:  <http://leventerkok.github.io/sbv/> -* Latest Hackage released version: 8.17, 2021-10-25+* Latest Hackage released version: 9.0, 2022-04-27 +### Version 9.0++  * Changes required to compile cleanly with GHC 9.2 series.++  * In future versions, GHC will make `forall` a reserved word, which will create a conflict with SBV's use of the same.+    To accommodate for these changes and to be consistent, following identifiers were renamed:++       - `forall`   --> `sbvForall`+       - `forall_`  --> `sbvForall_`+       - `exists`   --> `sbvExists`+       - `exists_`  --> `sbvExists_`+       - `forAll`   --> `universal`+       - `forAll_`  --> `universal_`+       - `forSome`  --> `existential`+       - `forSome_` --> `existential_`++   * Add support for `reverse` on symbolic lists and strings. Note that this definition uses a recursive function+     declaration in SMTLib, so any proof involving inductive reasoning will likely not-terminate. However, it+     should be usable at ground-level and for simpler non-inductive properties. Of course, as SMT-solvers mature+     this can change in the future.++   * Changed the String/List versions of `.++/.!!` to directly use the names `++/!!`. Since these modules+     are intended to be used qualified only, there's no reason to add the dots.++   * Added function `addSMTDefinition`, which allows users to give direct definitions of SMTLib functions. This+     is useful for defining recursive functions that are not symbolically terminating.++   * Added `Documentation.SBV.Examples.Lists.CountOutAndTransfer` example, proving that the so-called+     coating card trick works correctly.++   * Added `Documentation.SBV.Examples.Puzzles.Jugs` example, solving the water-jug transfer puzzle.++   * Added `Documentation.SBV.Examples.Puzzles.AOC_2021_24` example, showing how to model an EDSL in SBV,+     solving the advent-of-code, 2021, day 24 problem.++   * Added `Documentation.SBV.Examples.Puzzles.Drinker` example, proving the famous Drinker paradox of+     Raymond Smullyan.++   * Added concrete type instances of Mergeable class.++   * Fixed a bug in the implementation of the concrete-path for sPopCount+   +   * Added complement, power, and difference operators for regular expressions. Also added `everything`, `nothing`,+     `anyChar` as new recognizers.++   * Fixed the semantics of `All` regular expressions to recognize all-strings, and added `AllChar` as a+     new regular-expression constructor to match any single regular expression. Thanks to Matt Torrence for+     the patch.++   * Fixed a bug in the concrete implementation of bit-vector join, which didn't handle signed quantities+     correctly. Thanks to Sirui Lu for the report and test cases.+ ### Version 8.17, 2021-10-25    * SBV now supports cvc5; the latest incarnation of CVC. See https://github.com/cvc5/cvc5@@ -18,6 +70,8 @@    * Add missing instances of SatModel for Char and String. Thanks to eax- on github     for the contribution.++  * Add support for symbolic comparison of regular expressions.    * Export svToSV from Data.SBV.Dynamic. Thanks to Matt Parker for the PR. 
@@ -1,4 +1,4 @@-Copyright (c) 2010-2021, Levent Erkok (erkokl@gmail.com)+Copyright (c) 2010-2022, Levent Erkok (erkokl@gmail.com) All rights reserved.  The sbv library is distributed with the BSD3 license. See the LICENSE file
Data/SBV.hs view
@@ -136,6 +136,13 @@ -- get in touch if there is a solver you'd like to see included. ----------------------------------------------------------------------------- +{-# LANGUAGE DataKinds            #-}+{-# LANGUAGE FlexibleInstances    #-}+{-# LANGUAGE ScopedTypeVariables  #-}+{-# LANGUAGE TypeApplications     #-}+{-# LANGUAGE TypeFamilies         #-}+{-# LANGUAGE TypeOperators        #-}+ {-# OPTIONS_GHC -Wall -Werror #-}  module Data.SBV (@@ -239,6 +246,7 @@   , sSets    -- * Symbolic Equality and Comparisons+  -- $distinctNote   , EqSymbolic(..), OrdSymbolic(..), Equality(..)   -- * Conditionals: Mergeable values   , Mergeable(..), ite, iteLazy@@ -264,6 +272,7 @@   -- ** Rounding modes   , sRoundNearestTiesToEven, sRoundNearestTiesToAway, sRoundTowardPositive, sRoundTowardNegative, sRoundTowardZero, sRNE, sRNA, sRTP, sRTN, sRTZ   -- ** Conversion to/from floats+  -- $conversionNote   , IEEEFloatConvertible(..)    -- ** Bit-pattern conversions@@ -287,12 +296,15 @@   -- $uninterpreted   , mkUninterpretedSort, Uninterpreted(..), addAxiom +  -- * Adding SMT functions+  , addSMTDefinition+   -- * Properties, proofs, and satisfiability   -- $proveIntro   -- $noteOnNestedQuantifiers   -- $multiIntro   , Predicate, Goal-  , Provable, forAll_, forAll, forSome_, forSome+  , Provable, universal_, universal, existential_, existential   , prove, proveWith   , dprove, dproveWith   , sat, satWith@@ -378,7 +390,7 @@    -- * Abstract SBV type   , SBV, HasKind(..), Kind(..)-  , SymVal, forall, forall_, mkForallVars, exists, exists_, mkExistVars, free+  , SymVal, sbvForall, sbvForall_, mkForallVars, sbvExists, sbvExists_, mkExistVars, free   , free_, mkFreeVars, symbolic, symbolics, literal, unliteral, fromCV   , isConcrete, isSymbolic, isConcretely, mkSymVal   , MonadSymbolic(..), Symbolic, SymbolicT, label, output, runSMT, runSMTWith@@ -393,13 +405,13 @@   ) where  import Data.SBV.Core.AlgReals-import Data.SBV.Core.Data       hiding (forall, forall_,-                                        mkForallVars, exists, exists_,+import Data.SBV.Core.Data       hiding (sbvForall, sbvForall_,+                                        mkForallVars, sbvExists, sbvExists_,                                         mkExistVars, free, free_, mkFreeVars,                                         output, symbolic, symbolics, mkSymVal,                                         newArray, newArray_) import Data.SBV.Core.Model      hiding (assertWithPenalty, minimize, maximize,-                                        forall, forall_, exists, exists_,+                                        sbvForall, sbvForall_, sbvExists, sbvExists_,                                         solve, sBool, sBool_, sBools, sChar, sChar_, sChars,                                         sDouble, sDouble_, sDoubles, sFloat, sFloat_, sFloats,                                         sFloatingPoint, sFloatingPoint_, sFloatingPoints,@@ -412,8 +424,14 @@                                         sRational, sRational_, sRationals,                                         sWord8, sWord8_, sWord8s, sWord16, sWord16_, sWord16s,                                         sWord32, sWord32_, sWord32s, sWord64, sWord64_, sWord64s,-                                        sMaybe, sMaybe_, sMaybes, sEither, sEither_, sEithers, sSet, sSet_, sSets)-import Data.SBV.Core.Sized      hiding (sWord, sWord_, sWords, sInt, sInt_, sInts)+                                        sMaybe, sMaybe_, sMaybes, sEither, sEither_, sEithers, sSet, sSet_, sSets,+                                        sBarrelRotateLeft, sBarrelRotateRight)++import qualified Data.SBV.Core.Model as M (sBarrelRotateLeft, sBarrelRotateRight)++import           Data.SBV.Core.Sized       hiding (sWord, sWord_, sWords, sInt, sInt_, sInts, bvExtract, (#), zeroExtend, signExtend, bvDrop, bvTake)+import qualified Data.SBV.Core.Sized as CS+ import Data.SBV.Core.Kind  import Data.SBV.Core.SizedFloats@@ -421,7 +439,7 @@ import Data.SBV.Core.Floating import Data.SBV.Core.Symbolic   (MonadSymbolic(..), SymbolicT) -import Data.SBV.Provers.Prover hiding (forAll_, forAll, forSome_, forSome,+import Data.SBV.Provers.Prover hiding (universal_, universal, existential_, existential,                                        prove, proveWith, sat, satWith, allSat,                                        dsat, dsatWith, dprove, dproveWith,                                        allSatWith, optimize, optimizeWith,@@ -445,6 +463,16 @@  import qualified Data.SBV.Utils.CrackNum as CN +import Data.Proxy (Proxy(..))+import GHC.TypeLits++import Prelude hiding((+), (-), (*)) -- to avoid the haddock ambiguity++--- $setup+--- >>> -- For doctest purposes only:+--- >>> :set -XDataKinds+--- >>> import Data.Proxy+ -- | Show a value in detailed (cracked) form, if possible. -- This makes most sense with numbers, and especially floating-point types. crack :: SBV a -> String@@ -747,18 +775,12 @@ {- $strings Support for characters, strings, and regular expressions (initial version contributed by Joel Burget) adds support for QF_S logic, described here: <http://smtlib.cs.uiowa.edu/theories-UnicodeStrings.shtml>-and here: <http://rise4fun.com/z3/tutorialcontent/sequences>. Note-that this logic is still not part of official SMTLib (as of March 2018), so it should be considered-experimental.  See "Data.SBV.Char", "Data.SBV.String", "Data.SBV.RegExp" for related functions. -}  {- $lists-Support for symbolic lists (initial version contributed by Joel Burget)-adds support for sequence support, described here: <http://rise4fun.com/z3/tutorialcontent/sequences>. Note-that this logic is still not part of official SMTLib (as of March 2018), so it should be considered-experimental.+Support for symbolic lists (initial version contributed by Joel Burget) adds support for sequence support.  See "Data.SBV.List" for related functions. -}@@ -778,8 +800,8 @@ example:  @-   do x <- 'exists' \"x\"-      y <- 'exists' \"y\"+   do x <- 'sbvExists' \"x\"+      y <- 'sbvExists' \"y\"       'constrain' $ x .> y       'constrain' $ x + y .>= 12       'constrain' $ y .>= 3@@ -817,7 +839,7 @@  {- $generalConstraints A good use case (in fact the motivating use case) for 'constrain' is attaching a-constraint to a 'forall' or 'exists' variable at the time of its creation.+constraint to a universally or existentially quantified variable at the time of its creation. Also, the conjunctive semantics for 'sat' and the implicative semantics for 'prove' simplify programming by choosing the correct interpretation automatically. However, one should be aware of the semantic difference. For instance, in@@ -825,7 +847,7 @@ /satisfiable/. To wit, consider:   @-    do x <- 'exists' \"x\"+    do x <- 'sbvExists' \"x\"        'constrain' $ x .< x        return $ x .< (x :: 'SWord8')  @@@ -968,7 +990,7 @@ -}  {- $noteOnNestedQuantifiers-=== A note on reasoning in the presence of quantifiers+=== A note on reasoning in the presence of quantifiers #noteOnNested#  Note that SBV allows reasoning with quantifiers: Inputs can be existentially or universally quantified. Predicates can be built with arbitrary nesting of such quantifiers as well. However, SBV always /assumes/ that the input is in@@ -978,7 +1000,7 @@ with other code. The rule is simple, however: All inputs are assumed at the top, in the order declared, regardless of their quantifiers. SBV will apply skolemization to get rid of existentials before sending predicates to backend solvers. However, if you do want nested quantification, you will manually have to first convert to prenex-normal form (which produces an equisatisfiable but not necessarily-equivalent formula), and code that explicitly in SBV. See <http://github.com/LeventErkok/sbv/issues/256> for a detailed discussion+equivalent formula), and code that explicitly in SBV. See [Issue 256](http://github.com/LeventErkok/sbv/issues/256) and [Issue 623](https://github.com/LeventErkok/sbv/issues/623) for a detailed discussion of this issue. -} @@ -1046,5 +1068,401 @@ you have lots of "debugging" points, but not all are of interest. Use the 'sObserve' variant when you are at the 'Symbolic' monad, which also supports quick-check applications. -}++{- $distinctNote+Symbolic equality provides the notion of what it means to be equal, similar to Haskell's 'Eq' class, except allowing comparison of+symbolic values. The methods are '.==' and './=', returning 'SBool' results. We also provide a notion of strong equality ('.===' and './=='),+which is useful for floating-point value comparisons as it deals more uniformly with @NaN@ and positive/negative zeros. Additionally, we+provide 'distinct' that can be used to assert all elements of a list are different from each other, and 'distinctExcept' which is similar+to 'distinct' but allows for certain values to be considered different. These latter two functions are useful in modeling a variety of+puzzles and cardinality constraints:++>>> prove $ \a -> distinctExcept [a, a] [0::SInteger] .<=> a .== 0+Q.E.D.+>>> prove $ \a b -> distinctExcept [a, b] [0::SWord8] .<=> (a .== b .=> a .== 0)+Q.E.D.+>>> prove $ \a b c d -> distinctExcept [a, b, c, d] [] .== distinct [a, b, c, (d::SInteger)]+Q.E.D.+-}++{- $conversionNote+Capture convertability from/to FloatingPoint representations.++Conversions to float: 'toSFloat' and 'toSDouble' simply return the+nearest representable float from the given type based on the rounding+mode provided. Similarly, 'toSFloatingPoint' converts to a generalized+floating-point number with specified exponent and significand bith widths.++Conversions from float: 'fromSFloat', 'fromSDouble', 'fromSFloatingPoint' functions do+the reverse conversion. However some care is needed when given values+that are not representable in the integral target domain. For instance,+converting an 'SFloat' to an 'SInt8' is problematic. The rules are as follows:++If the input value is a finite point and when rounded in the given rounding mode to an+integral value lies within the target bounds, then that result is returned.+(This is the regular interpretation of rounding in IEEE754.)++Otherwise (i.e., if the integral value in the float or double domain) doesn't+fit into the target type, then the result is unspecified. Note that if the input+is @+oo@, @-oo@, or @NaN@, then the result is unspecified.++Due to the unspecified nature of conversions, SBV will never constant fold+conversions from floats to integral values. That is, you will always get a+symbolic value as output. (Conversions from floats to other floats will be+constant folded. Conversions from integral values to floats will also be+constant folded.)++Note that unspecified really means unspecified: In particular, SBV makes+no guarantees about matching the behavior between what you might get in+Haskell, via SMT-Lib, or the C-translation. If the input value is out-of-bounds+as defined above, or is @NaN@ or @oo@ or @-oo@, then all bets are off. In particular+C and SMTLib are decidedly undefine this case, though that doesn't mean they do the+same thing! Same goes for Haskell, which seems to convert via Int64, but we do+not model that behavior in SBV as it doesn't seem to be intentional nor well documented.++You can check for @NaN@, @oo@ and @-oo@, using the predicates 'fpIsNaN', 'fpIsInfinite',+and 'fpIsPositive', 'fpIsNegative' predicates, respectively; and do the proper conversion+based on your needs. (0 is a good choice, as are min/max bounds of the target type.)++Currently, SBV provides no predicates to check if a value would lie within range for a+particular conversion task, as this depends on the rounding mode and the types involved+and can be rather tricky to determine. (See <http://github.com/LeventErkok/sbv/issues/456>+for a discussion of the issues involved.) In a future release, we hope to be able to+provide underflow and overflow predicates for these conversions as well.++Some examples to illustrate the behavior follows:++>>> :{+roundTrip :: forall a. (Eq a, IEEEFloatConvertible a) => SRoundingMode -> SBV a -> SBool+roundTrip m x = fromSFloat m (toSFloat m x) .== x+:}++>>> prove $ roundTrip @Int8+Q.E.D.+>>> prove $ roundTrip @Word8+Q.E.D.+>>> prove $ roundTrip @Int16+Q.E.D.+>>> prove $ roundTrip @Word16+Q.E.D.+>>> prove $ roundTrip @Int32+Falsifiable. Counter-example:+  s0 = RoundNearestTiesToEven :: RoundingMode+  s1 =             -156765620 :: Int32++Note how we get a failure on `Int32`. The counter-example value is not representable exactly as a single precision float:++>>> toRational (-156765620 :: Float)+(-156765616) % 1++Note how the numerator is different, it is off by 4. This is hardly surprising, since floats become sparser as+the magnitude increases to be able to cover all the integer values representable.++>>> :{+roundTrip :: forall a. (Eq a, IEEEFloatConvertible a) => SRoundingMode -> SBV a -> SBool+roundTrip m x = fromSDouble m (toSDouble m x) .== x+:}++>>> prove $ roundTrip @Int8+Q.E.D.+>>> prove $ roundTrip @Word8+Q.E.D.+>>> prove $ roundTrip @Int16+Q.E.D.+>>> prove $ roundTrip @Word16+Q.E.D.+>>> prove $ roundTrip @Int32+Q.E.D.+>>> prove $ roundTrip @Word32+Q.E.D.+>>> prove $ roundTrip @Int64+Falsifiable. Counter-example:+  s0 = RoundTowardNegative :: RoundingMode+  s1 =    9007199254740995 :: Int64++Just like in the `SFloat` case, once we reach 64-bits, we no longer can exactly represent the+integer value for all possible values:++>>>  toRational (9007199254740995 :: Double)+9007199254740996 % 1++In this case the numerator is off by 1.+-}++-- | An implementation of rotate-left, using a barrel shifter like design. Only works when both+-- arguments are finite bitvectors, and furthermore when the second argument is unsigned.+-- The first condition is enforced by the type, but the second is dynamically checked.+-- We provide this implementation as an alternative to `sRotateLeft` since SMTLib logic+-- does not support variable argument rotates (as opposed to shifts), and thus this+-- implementation can produce better code for verification compared to `sRotateLeft`.+--+-- >>> prove $ \x y -> (x `sBarrelRotateLeft`  y) `sBarrelRotateRight` (y :: SWord32) .== (x :: SWord64)+-- Q.E.D.+sBarrelRotateLeft :: (SFiniteBits a, SFiniteBits b) => SBV a -> SBV b -> SBV a+sBarrelRotateLeft = M.sBarrelRotateLeft++-- | An implementation of rotate-right, using a barrel shifter like design. See comments+-- for `sBarrelRotateLeft` for details.+--+-- >>> prove $ \x y -> (x `sBarrelRotateRight` y) `sBarrelRotateLeft`  (y :: SWord32) .== (x :: SWord64)+-- Q.E.D.+sBarrelRotateRight :: (SFiniteBits a, SFiniteBits b) => SBV a -> SBV b -> SBV a+sBarrelRotateRight = M.sBarrelRotateRight++-- | Extract a portion of bits to form a smaller bit-vector.+--+-- >>> prove $ \x -> bvExtract (Proxy @7) (Proxy @3) (x :: SWord 12) .== bvDrop (Proxy @4) (bvTake (Proxy @9) x)+-- Q.E.D.+bvExtract :: forall i j n bv proxy. ( KnownNat n, BVIsNonZero n, SymVal (bv n)+                                    , KnownNat i+                                    , KnownNat j+                                    , i + 1 <= n+                                    , j <= i+                                    , BVIsNonZero (i - j + 1)+                                    ) => proxy i                -- ^ @i@: Start position, numbered from @n-1@ to @0@+                                      -> proxy j                -- ^ @j@: End position, numbered from @n-1@ to @0@, @j <= i@ must hold+                                      -> SBV (bv n)             -- ^ Input bit vector of size @n@+                                      -> SBV (bv (i - j + 1))   -- ^ Output is of size @i - j + 1@+bvExtract = CS.bvExtract++-- | Join two bitvectors.+--+-- >>> prove $ \x y -> x .== bvExtract (Proxy @79) (Proxy @71) ((x :: SWord 9) # (y :: SWord 71))+-- Q.E.D.+(#) :: ( KnownNat n, BVIsNonZero n, SymVal (bv n)+       , KnownNat m, BVIsNonZero m, SymVal (bv m)+       ) => SBV (bv n)                     -- ^ First input, of size @n@, becomes the left side+         -> SBV (bv m)                     -- ^ Second input, of size @m@, becomes the right side+         -> SBV (bv (n + m))               -- ^ Concatenation, of size @n+m@+(#) = (CS.#)+infixr 5 #++-- | Zero extend a bit-vector.+--+-- >>> prove $ \x -> bvExtract (Proxy @20) (Proxy @12) (zeroExtend (x :: SInt 12) :: SInt 21) .== 0+-- Q.E.D.+zeroExtend :: forall n m bv. ( KnownNat n, BVIsNonZero n, SymVal (bv n)+                             , KnownNat m, BVIsNonZero m, SymVal (bv m)+                             , n + 1 <= m+                             , SIntegral (bv (m - n))+                             , BVIsNonZero (m - n)+                             ) => SBV (bv n)    -- ^ Input, of size @n@+                               -> SBV (bv m)    -- ^ Output, of size @m@. @n < m@ must hold+zeroExtend = CS.zeroExtend++-- | Sign extend a bit-vector.+--+-- >>> prove $ \x -> sNot (msb x) .=> bvExtract (Proxy @20) (Proxy @12) (signExtend (x :: SInt 12) :: SInt 21) .== 0+-- Q.E.D.+-- >>> prove $ \x ->       msb x  .=> bvExtract (Proxy @20) (Proxy @12) (signExtend (x :: SInt 12) :: SInt 21) .== complement 0+-- Q.E.D.+signExtend :: forall n m bv. ( KnownNat n, BVIsNonZero n, SymVal (bv n)+                             , KnownNat m, BVIsNonZero m, SymVal (bv m)+                             , n + 1 <= m+                             , SFiniteBits (bv n)+                             , SIntegral   (bv (m - n))+                             , BVIsNonZero   (m - n)+                             ) => SBV (bv n)  -- ^ Input, of size @n@+                               -> SBV (bv m)  -- ^ Output, of size @m@. @n < m@ must hold+signExtend = CS.signExtend++-- | Drop bits from the top of a bit-vector.+--+-- >>> prove $ \x -> bvDrop (Proxy @0) (x :: SWord 43) .== x+-- Q.E.D.+-- >>> prove $ \x -> bvDrop (Proxy @20) (x :: SWord 21) .== ite (lsb x) 1 (0 :: SWord 1)+-- Q.E.D.+bvDrop :: forall i n m bv proxy. ( KnownNat n, BVIsNonZero n+                                 , KnownNat i+                                 , i + 1 <= n+                                 , i + m - n <= 0+                                 , BVIsNonZero (n - i)+                                 ) => proxy i                    -- ^ @i@: Number of bits to drop. @i < n@ must hold.+                                   -> SBV (bv n)                 -- ^ Input, of size @n@+                                   -> SBV (bv m)                 -- ^ Output, of size @m@. @m = n - i@ holds.+bvDrop = CS.bvDrop++-- | Take bits from the top of a bit-vector.+--+-- >>> prove $ \x -> bvTake (Proxy @13) (x :: SWord 13) .== x+-- Q.E.D.+-- >>> prove $ \x -> bvTake (Proxy @1) (x :: SWord 13) .== ite (msb x) 1 0+-- Q.E.D.+-- >>> prove $ \x -> bvTake (Proxy @4) x # bvDrop (Proxy @4) x .== (x :: SWord 23)+-- Q.E.D.+bvTake :: forall i n bv proxy. ( KnownNat n, BVIsNonZero n+                               , KnownNat i, BVIsNonZero i+                               , i <= n+                               ) => proxy i                  -- ^ @i@: Number of bits to take. @0 < i <= n@ must hold.+                                 -> SBV (bv n)               -- ^ Input, of size @n@+                                 -> SBV (bv i)               -- ^ Output, of size @i@+bvTake = CS.bvTake++-- | A helper class to convert sized bit-vectors to/from bytes.+class ByteConverter a where+   -- | Convert to a sequence of bytes+   --+   -- >>> prove $ \a b c d -> toBytes ((fromBytes [a, b, c, d]) :: SWord 32) .== [a, b, c, d]+   -- Q.E.D.+   toBytes   :: a -> [SWord 8]++   -- | Convert from a sequence of bytes+   --+   -- >>> prove $ \r -> fromBytes (toBytes r) .== (r :: SWord 64)+   -- Q.E.D.+   fromBytes :: [SWord 8] -> a++-- NB. The following instances are automatically generated by buildUtils/genByteConverter.hs+-- It is possible to write these more compactly indeed, but this explicit form generates+-- better C code, and hence we allow the verbosity here.++-- | 'SWord' 8 instance for 'ByteConverter'+instance ByteConverter (SWord 8) where+   toBytes a = [a]++   fromBytes [x] = x+   fromBytes as  = error $ "fromBytes:SWord 8: Incorrect number of bytes: " ++ show (length as)++-- | 'SWord' 16 instance for 'ByteConverter'+instance ByteConverter (SWord 16) where+   toBytes a = [ bvExtract (Proxy @15) (Proxy  @8) a+               , bvExtract (Proxy  @7) (Proxy  @0) a+               ]++   fromBytes as+     | l == 2+     = (fromBytes :: [SWord 8] -> SWord 8) (take 1 as) # fromBytes (drop 1 as)+     | True+     = error $ "fromBytes:SWord 16: Incorrect number of bytes: " ++ show l+     where l = length as++-- | 'SWord' 32 instance for 'ByteConverter'+instance ByteConverter (SWord 32) where+   toBytes a = [ bvExtract (Proxy @31) (Proxy @24) a, bvExtract (Proxy @23) (Proxy @16) a, bvExtract (Proxy @15) (Proxy  @8) a, bvExtract (Proxy  @7) (Proxy  @0) a+               ]++   fromBytes as+     | l == 4+     = (fromBytes :: [SWord 8] -> SWord 16) (take 2 as) # fromBytes (drop 2 as)+     | True+     = error $ "fromBytes:SWord 32: Incorrect number of bytes: " ++ show l+     where l = length as++-- | 'SWord' 64 instance for 'ByteConverter'+instance ByteConverter (SWord 64) where+   toBytes a = [ bvExtract (Proxy @63) (Proxy @56) a, bvExtract (Proxy @55) (Proxy @48) a, bvExtract (Proxy @47) (Proxy @40) a, bvExtract (Proxy @39) (Proxy @32) a+               , bvExtract (Proxy @31) (Proxy @24) a, bvExtract (Proxy @23) (Proxy @16) a, bvExtract (Proxy @15) (Proxy  @8) a, bvExtract (Proxy  @7) (Proxy  @0) a+               ]++   fromBytes as+     | l == 8+     = (fromBytes :: [SWord 8] -> SWord 32) (take 4 as) # fromBytes (drop 4 as)+     | True+     = error $ "fromBytes:SWord 64: Incorrect number of bytes: " ++ show l+     where l = length as++-- | 'SWord' 128 instance for 'ByteConverter'+instance ByteConverter (SWord 128) where+   toBytes a = [ bvExtract (Proxy @127) (Proxy @120) a, bvExtract (Proxy @119) (Proxy @112) a, bvExtract (Proxy @111) (Proxy @104) a, bvExtract (Proxy @103) (Proxy  @96) a+               , bvExtract (Proxy  @95) (Proxy  @88) a, bvExtract (Proxy  @87) (Proxy  @80) a, bvExtract (Proxy  @79) (Proxy  @72) a, bvExtract (Proxy  @71) (Proxy  @64) a+               , bvExtract (Proxy  @63) (Proxy  @56) a, bvExtract (Proxy  @55) (Proxy  @48) a, bvExtract (Proxy  @47) (Proxy  @40) a, bvExtract (Proxy  @39) (Proxy  @32) a+               , bvExtract (Proxy  @31) (Proxy  @24) a, bvExtract (Proxy  @23) (Proxy  @16) a, bvExtract (Proxy  @15) (Proxy   @8) a, bvExtract (Proxy   @7) (Proxy   @0) a+               ]++   fromBytes as+     | l == 16+     = (fromBytes :: [SWord 8] -> SWord 64) (take 8 as) # fromBytes (drop 8 as)+     | True+     = error $ "fromBytes:SWord 128: Incorrect number of bytes: " ++ show l+     where l = length as++-- | 'SWord' 256 instance for 'ByteConverter'+instance ByteConverter (SWord 256) where+   toBytes a = [ bvExtract (Proxy @255) (Proxy @248) a, bvExtract (Proxy @247) (Proxy @240) a, bvExtract (Proxy @239) (Proxy @232) a, bvExtract (Proxy @231) (Proxy @224) a+               , bvExtract (Proxy @223) (Proxy @216) a, bvExtract (Proxy @215) (Proxy @208) a, bvExtract (Proxy @207) (Proxy @200) a, bvExtract (Proxy @199) (Proxy @192) a+               , bvExtract (Proxy @191) (Proxy @184) a, bvExtract (Proxy @183) (Proxy @176) a, bvExtract (Proxy @175) (Proxy @168) a, bvExtract (Proxy @167) (Proxy @160) a+               , bvExtract (Proxy @159) (Proxy @152) a, bvExtract (Proxy @151) (Proxy @144) a, bvExtract (Proxy @143) (Proxy @136) a, bvExtract (Proxy @135) (Proxy @128) a+               , bvExtract (Proxy @127) (Proxy @120) a, bvExtract (Proxy @119) (Proxy @112) a, bvExtract (Proxy @111) (Proxy @104) a, bvExtract (Proxy @103) (Proxy  @96) a+               , bvExtract (Proxy  @95) (Proxy  @88) a, bvExtract (Proxy  @87) (Proxy  @80) a, bvExtract (Proxy  @79) (Proxy  @72) a, bvExtract (Proxy  @71) (Proxy  @64) a+               , bvExtract (Proxy  @63) (Proxy  @56) a, bvExtract (Proxy  @55) (Proxy  @48) a, bvExtract (Proxy  @47) (Proxy  @40) a, bvExtract (Proxy  @39) (Proxy  @32) a+               , bvExtract (Proxy  @31) (Proxy  @24) a, bvExtract (Proxy  @23) (Proxy  @16) a, bvExtract (Proxy  @15) (Proxy   @8) a, bvExtract (Proxy   @7) (Proxy   @0) a+               ]++   fromBytes as+     | l == 32+     = (fromBytes :: [SWord 8] -> SWord 128) (take 16 as) # fromBytes (drop 16 as)+     | True+     = error $ "fromBytes:SWord 256: Incorrect number of bytes: " ++ show l+     where l = length as++-- | 'SWord' 512 instance for 'ByteConverter'+instance ByteConverter (SWord 512) where+   toBytes a = [ bvExtract (Proxy @511) (Proxy @504) a, bvExtract (Proxy @503) (Proxy @496) a, bvExtract (Proxy @495) (Proxy @488) a, bvExtract (Proxy @487) (Proxy @480) a+               , bvExtract (Proxy @479) (Proxy @472) a, bvExtract (Proxy @471) (Proxy @464) a, bvExtract (Proxy @463) (Proxy @456) a, bvExtract (Proxy @455) (Proxy @448) a+               , bvExtract (Proxy @447) (Proxy @440) a, bvExtract (Proxy @439) (Proxy @432) a, bvExtract (Proxy @431) (Proxy @424) a, bvExtract (Proxy @423) (Proxy @416) a+               , bvExtract (Proxy @415) (Proxy @408) a, bvExtract (Proxy @407) (Proxy @400) a, bvExtract (Proxy @399) (Proxy @392) a, bvExtract (Proxy @391) (Proxy @384) a+               , bvExtract (Proxy @383) (Proxy @376) a, bvExtract (Proxy @375) (Proxy @368) a, bvExtract (Proxy @367) (Proxy @360) a, bvExtract (Proxy @359) (Proxy @352) a+               , bvExtract (Proxy @351) (Proxy @344) a, bvExtract (Proxy @343) (Proxy @336) a, bvExtract (Proxy @335) (Proxy @328) a, bvExtract (Proxy @327) (Proxy @320) a+               , bvExtract (Proxy @319) (Proxy @312) a, bvExtract (Proxy @311) (Proxy @304) a, bvExtract (Proxy @303) (Proxy @296) a, bvExtract (Proxy @295) (Proxy @288) a+               , bvExtract (Proxy @287) (Proxy @280) a, bvExtract (Proxy @279) (Proxy @272) a, bvExtract (Proxy @271) (Proxy @264) a, bvExtract (Proxy @263) (Proxy @256) a+               , bvExtract (Proxy @255) (Proxy @248) a, bvExtract (Proxy @247) (Proxy @240) a, bvExtract (Proxy @239) (Proxy @232) a, bvExtract (Proxy @231) (Proxy @224) a+               , bvExtract (Proxy @223) (Proxy @216) a, bvExtract (Proxy @215) (Proxy @208) a, bvExtract (Proxy @207) (Proxy @200) a, bvExtract (Proxy @199) (Proxy @192) a+               , bvExtract (Proxy @191) (Proxy @184) a, bvExtract (Proxy @183) (Proxy @176) a, bvExtract (Proxy @175) (Proxy @168) a, bvExtract (Proxy @167) (Proxy @160) a+               , bvExtract (Proxy @159) (Proxy @152) a, bvExtract (Proxy @151) (Proxy @144) a, bvExtract (Proxy @143) (Proxy @136) a, bvExtract (Proxy @135) (Proxy @128) a+               , bvExtract (Proxy @127) (Proxy @120) a, bvExtract (Proxy @119) (Proxy @112) a, bvExtract (Proxy @111) (Proxy @104) a, bvExtract (Proxy @103) (Proxy  @96) a+               , bvExtract (Proxy  @95) (Proxy  @88) a, bvExtract (Proxy  @87) (Proxy  @80) a, bvExtract (Proxy  @79) (Proxy  @72) a, bvExtract (Proxy  @71) (Proxy  @64) a+               , bvExtract (Proxy  @63) (Proxy  @56) a, bvExtract (Proxy  @55) (Proxy  @48) a, bvExtract (Proxy  @47) (Proxy  @40) a, bvExtract (Proxy  @39) (Proxy  @32) a+               , bvExtract (Proxy  @31) (Proxy  @24) a, bvExtract (Proxy  @23) (Proxy  @16) a, bvExtract (Proxy  @15) (Proxy   @8) a, bvExtract (Proxy   @7) (Proxy   @0) a+               ]++   fromBytes as+     | l == 64+     = (fromBytes :: [SWord 8] -> SWord 256) (take 32 as) # fromBytes (drop 32 as)+     | True+     = error $ "fromBytes:SWord 512: Incorrect number of bytes: " ++ show l+     where l = length as++-- | 'SWord' 1024 instance for 'ByteConverter'+instance ByteConverter (SWord 1024) where+   toBytes a = [ bvExtract (Proxy @1023) (Proxy @1016) a, bvExtract (Proxy @1015) (Proxy @1008) a, bvExtract (Proxy @1007) (Proxy @1000) a, bvExtract (Proxy  @999) (Proxy  @992) a+               , bvExtract (Proxy  @991) (Proxy  @984) a, bvExtract (Proxy  @983) (Proxy  @976) a, bvExtract (Proxy  @975) (Proxy  @968) a, bvExtract (Proxy  @967) (Proxy  @960) a+               , bvExtract (Proxy  @959) (Proxy  @952) a, bvExtract (Proxy  @951) (Proxy  @944) a, bvExtract (Proxy  @943) (Proxy  @936) a, bvExtract (Proxy  @935) (Proxy  @928) a+               , bvExtract (Proxy  @927) (Proxy  @920) a, bvExtract (Proxy  @919) (Proxy  @912) a, bvExtract (Proxy  @911) (Proxy  @904) a, bvExtract (Proxy  @903) (Proxy  @896) a+               , bvExtract (Proxy  @895) (Proxy  @888) a, bvExtract (Proxy  @887) (Proxy  @880) a, bvExtract (Proxy  @879) (Proxy  @872) a, bvExtract (Proxy  @871) (Proxy  @864) a+               , bvExtract (Proxy  @863) (Proxy  @856) a, bvExtract (Proxy  @855) (Proxy  @848) a, bvExtract (Proxy  @847) (Proxy  @840) a, bvExtract (Proxy  @839) (Proxy  @832) a+               , bvExtract (Proxy  @831) (Proxy  @824) a, bvExtract (Proxy  @823) (Proxy  @816) a, bvExtract (Proxy  @815) (Proxy  @808) a, bvExtract (Proxy  @807) (Proxy  @800) a+               , bvExtract (Proxy  @799) (Proxy  @792) a, bvExtract (Proxy  @791) (Proxy  @784) a, bvExtract (Proxy  @783) (Proxy  @776) a, bvExtract (Proxy  @775) (Proxy  @768) a+               , bvExtract (Proxy  @767) (Proxy  @760) a, bvExtract (Proxy  @759) (Proxy  @752) a, bvExtract (Proxy  @751) (Proxy  @744) a, bvExtract (Proxy  @743) (Proxy  @736) a+               , bvExtract (Proxy  @735) (Proxy  @728) a, bvExtract (Proxy  @727) (Proxy  @720) a, bvExtract (Proxy  @719) (Proxy  @712) a, bvExtract (Proxy  @711) (Proxy  @704) a+               , bvExtract (Proxy  @703) (Proxy  @696) a, bvExtract (Proxy  @695) (Proxy  @688) a, bvExtract (Proxy  @687) (Proxy  @680) a, bvExtract (Proxy  @679) (Proxy  @672) a+               , bvExtract (Proxy  @671) (Proxy  @664) a, bvExtract (Proxy  @663) (Proxy  @656) a, bvExtract (Proxy  @655) (Proxy  @648) a, bvExtract (Proxy  @647) (Proxy  @640) a+               , bvExtract (Proxy  @639) (Proxy  @632) a, bvExtract (Proxy  @631) (Proxy  @624) a, bvExtract (Proxy  @623) (Proxy  @616) a, bvExtract (Proxy  @615) (Proxy  @608) a+               , bvExtract (Proxy  @607) (Proxy  @600) a, bvExtract (Proxy  @599) (Proxy  @592) a, bvExtract (Proxy  @591) (Proxy  @584) a, bvExtract (Proxy  @583) (Proxy  @576) a+               , bvExtract (Proxy  @575) (Proxy  @568) a, bvExtract (Proxy  @567) (Proxy  @560) a, bvExtract (Proxy  @559) (Proxy  @552) a, bvExtract (Proxy  @551) (Proxy  @544) a+               , bvExtract (Proxy  @543) (Proxy  @536) a, bvExtract (Proxy  @535) (Proxy  @528) a, bvExtract (Proxy  @527) (Proxy  @520) a, bvExtract (Proxy  @519) (Proxy  @512) a+               , bvExtract (Proxy  @511) (Proxy  @504) a, bvExtract (Proxy  @503) (Proxy  @496) a, bvExtract (Proxy  @495) (Proxy  @488) a, bvExtract (Proxy  @487) (Proxy  @480) a+               , bvExtract (Proxy  @479) (Proxy  @472) a, bvExtract (Proxy  @471) (Proxy  @464) a, bvExtract (Proxy  @463) (Proxy  @456) a, bvExtract (Proxy  @455) (Proxy  @448) a+               , bvExtract (Proxy  @447) (Proxy  @440) a, bvExtract (Proxy  @439) (Proxy  @432) a, bvExtract (Proxy  @431) (Proxy  @424) a, bvExtract (Proxy  @423) (Proxy  @416) a+               , bvExtract (Proxy  @415) (Proxy  @408) a, bvExtract (Proxy  @407) (Proxy  @400) a, bvExtract (Proxy  @399) (Proxy  @392) a, bvExtract (Proxy  @391) (Proxy  @384) a+               , bvExtract (Proxy  @383) (Proxy  @376) a, bvExtract (Proxy  @375) (Proxy  @368) a, bvExtract (Proxy  @367) (Proxy  @360) a, bvExtract (Proxy  @359) (Proxy  @352) a+               , bvExtract (Proxy  @351) (Proxy  @344) a, bvExtract (Proxy  @343) (Proxy  @336) a, bvExtract (Proxy  @335) (Proxy  @328) a, bvExtract (Proxy  @327) (Proxy  @320) a+               , bvExtract (Proxy  @319) (Proxy  @312) a, bvExtract (Proxy  @311) (Proxy  @304) a, bvExtract (Proxy  @303) (Proxy  @296) a, bvExtract (Proxy  @295) (Proxy  @288) a+               , bvExtract (Proxy  @287) (Proxy  @280) a, bvExtract (Proxy  @279) (Proxy  @272) a, bvExtract (Proxy  @271) (Proxy  @264) a, bvExtract (Proxy  @263) (Proxy  @256) a+               , bvExtract (Proxy  @255) (Proxy  @248) a, bvExtract (Proxy  @247) (Proxy  @240) a, bvExtract (Proxy  @239) (Proxy  @232) a, bvExtract (Proxy  @231) (Proxy  @224) a+               , bvExtract (Proxy  @223) (Proxy  @216) a, bvExtract (Proxy  @215) (Proxy  @208) a, bvExtract (Proxy  @207) (Proxy  @200) a, bvExtract (Proxy  @199) (Proxy  @192) a+               , bvExtract (Proxy  @191) (Proxy  @184) a, bvExtract (Proxy  @183) (Proxy  @176) a, bvExtract (Proxy  @175) (Proxy  @168) a, bvExtract (Proxy  @167) (Proxy  @160) a+               , bvExtract (Proxy  @159) (Proxy  @152) a, bvExtract (Proxy  @151) (Proxy  @144) a, bvExtract (Proxy  @143) (Proxy  @136) a, bvExtract (Proxy  @135) (Proxy  @128) a+               , bvExtract (Proxy  @127) (Proxy  @120) a, bvExtract (Proxy  @119) (Proxy  @112) a, bvExtract (Proxy  @111) (Proxy  @104) a, bvExtract (Proxy  @103) (Proxy   @96) a+               , bvExtract (Proxy   @95) (Proxy   @88) a, bvExtract (Proxy   @87) (Proxy   @80) a, bvExtract (Proxy   @79) (Proxy   @72) a, bvExtract (Proxy   @71) (Proxy   @64) a+               , bvExtract (Proxy   @63) (Proxy   @56) a, bvExtract (Proxy   @55) (Proxy   @48) a, bvExtract (Proxy   @47) (Proxy   @40) a, bvExtract (Proxy   @39) (Proxy   @32) a+               , bvExtract (Proxy   @31) (Proxy   @24) a, bvExtract (Proxy   @23) (Proxy   @16) a, bvExtract (Proxy   @15) (Proxy    @8) a, bvExtract (Proxy    @7) (Proxy    @0) a+               ]++   fromBytes as+     | l == 128+     = (fromBytes :: [SWord 8] -> SWord 512) (take 64 as) # fromBytes (drop 64 as)+     | True+     = error $ "fromBytes:SWord 1024: Incorrect number of bytes: " ++ show l+     where l = length as  {-# ANN module ("HLint: ignore Use import/export shortcut" :: String) #-}
Data/SBV/Char.hs view
@@ -53,10 +53,11 @@  import Data.SBV.String (isInfixOf, singleton) --- For doctest use only--- -- $setup--- >>> import Data.SBV.Provers.Prover (prove, sat)+-- >>> -- For doctest purposes only:+-- >>> import Data.SBV+-- >>> import Data.SBV.String (isInfixOf, singleton)+-- >>> import Prelude hiding(elem, notElem) -- >>> :set -XOverloadedStrings  -- | Is the character in the string?
Data/SBV/Client.hs view
@@ -9,6 +9,7 @@ -- Cross-cutting toplevel client functions ----------------------------------------------------------------------------- +{-# LANGUAGE CPP                 #-} {-# LANGUAGE PackageImports      #-} {-# LANGUAGE QuasiQuotes         #-} {-# LANGUAGE ScopedTypeVariables #-}@@ -30,7 +31,10 @@  import qualified Control.Exception as C -import qualified "template-haskell" Language.Haskell.TH as TH+import qualified "template-haskell" Language.Haskell.TH        as TH+#if MIN_VERSION_template_haskell(2,18,0)+import qualified "template-haskell" Language.Haskell.TH.Syntax as TH+#endif  import Data.SBV.Core.Data import Data.SBV.Core.Model@@ -86,16 +90,32 @@      sType <- TH.conT ''SBV `TH.appT` typeCon -    let declConstructor c = [sig, def]-          where nm   = TH.mkName $ 's' : TH.nameBase c+    let declConstructor c = ((nm, bnm), [sig, def])+          where bnm  = TH.nameBase c+                nm   = TH.mkName $ 's' : bnm                 def  = TH.FunD nm [TH.Clause [] (TH.NormalB body) []]                 body = TH.AppE (TH.VarE 'literal) (TH.ConE c)                 sig  = TH.SigD nm sType -        cdecl = concatMap declConstructor cstrs+        (constrNames, cdecls) = unzip (map declConstructor cstrs) -    let tdecl = TH.TySynD (TH.mkName ('S' : TH.nameBase typeName)) [] sType-    pure $ deriveEqOrds ++ derives ++ [tdecl] ++ cdecl+    let btname = TH.nameBase typeName+        tname  = TH.mkName ('S' : btname)+        tdecl  = TH.TySynD tname [] sType++    addDocs (tname, btname) constrNames++    pure $ deriveEqOrds ++ derives ++ [tdecl] ++ concat cdecls++ where addDocs :: (TH.Name, String) -> [(TH.Name, String)] -> TH.Q ()+#if MIN_VERSION_template_haskell(2,18,0)+       addDocs (tnm, ts) cnms = do addDoc True (tnm, ts)+                                   mapM_  (addDoc False) cnms+          where addDoc True  (cnm, cs) = TH.addModFinalizer $ TH.putDoc (TH.DeclDoc cnm) $ "Symbolic version of the type '"        ++ cs ++ "'."+                addDoc False (cnm, cs) = TH.addModFinalizer $ TH.putDoc (TH.DeclDoc cnm) $ "Symbolic version of the constructor '" ++ cs ++ "'."+#else+       addDocs _ _ = pure ()+#endif  -- | Make an enumeration a symbolic type. mkSymbolicEnumeration :: TH.Name -> TH.Q [TH.Dec]
Data/SBV/Client/BaseIO.hs view
@@ -57,41 +57,60 @@ -- In this case the sbv library will use names of the form @s1, s2@, etc. to name these variables -- Example: ----- >  forAll_ $ \(x::SWord8) y -> x `shiftL` 2 .== y+-- >  universal_ $ \(x::SWord8) y -> x `shiftL` 2 .== y -- -- is a predicate with two arguments, captured using an ordinary Haskell function. Internally, -- @x@ will be named @s0@ and @y@ will be named @s1@. ----- NB. For a version which generalizes over the underlying monad, see 'Data.SBV.Trans.forAll_'-forAll_ :: Provable a => a -> Symbolic SBool-forAll_ = Trans.forAll_+-- Remember that SBV assumes that the input is in prenex-normal form.+-- That is, all quantifiers are at the beginning of the predicate. See+-- [note on reasoning in the presence of+-- quantifiers]("Data.SBV#noteOnNested") for more information.+--+-- NB. For a version which generalizes over the underlying monad, see 'Data.SBV.Trans.universal_'+universal_ :: Provable a => a -> Symbolic SBool+universal_ = Trans.universal_  -- | Turns a value into a predicate, allowing users to provide names for the inputs. -- If the user does not provide enough number of names for the variables, the remaining ones -- will be internally generated. Note that the names are only used for printing models and has no -- other significance; in particular, we do not check that they are unique. Example: ----- >  forAll ["x", "y"] $ \(x::SWord8) y -> x `shiftL` 2 .== y+-- >  universal ["x", "y"] $ \(x::SWord8) y -> x `shiftL` 2 .== y -- -- This is the same as above, except the variables will be named @x@ and @y@ respectively, -- simplifying the counter-examples when they are printed. ----- NB. For a version which generalizes over the underlying monad, see 'Data.SBV.Trans.forAll'-forAll :: Provable a => [String] -> a -> Symbolic SBool-forAll = Trans.forAll+-- Remember that SBV assumes that the input is in prenex-normal form.+-- That is, all quantifiers are at the beginning of the predicate. See+-- [note on reasoning in the presence of+-- quantifiers]("Data.SBV#noteOnNested") for more information.+--+-- NB. For a version which generalizes over the underlying monad, see 'Data.SBV.Trans.universal'+universal :: Provable a => [String] -> a -> Symbolic SBool+universal = Trans.universal --- | Turns a value into an existentially quantified predicate. (Indeed, 'exists' would have been--- a better choice here for the name, but alas it's already taken.)+-- | Turns a value into an existentially quantified predicate. ----- NB. For a version which generalizes over the underlying monad, see 'Data.SBV.Trans.forSome_'-forSome_ :: Provable a => a -> Symbolic SBool-forSome_ = Trans.forSome_+-- Remember that SBV assumes that the input is in prenex-normal form.+-- That is, all quantifiers are at the beginning of the predicate. See+-- [note on reasoning in the presence of+-- quantifiers]("Data.SBV#noteOnNested") for more information.+--+-- NB. For a version which generalizes over the underlying monad, see 'Data.SBV.Trans.existential_'+existential_ :: Provable a => a -> Symbolic SBool+existential_ = Trans.existential_ --- | Version of 'forSome' that allows user defined names.+-- | Version of 'existential_' that allows user defined names. ----- NB. For a version which generalizes over the underlying monad, see 'Data.SBV.Trans.forSome'-forSome :: Provable a => [String] -> a -> Symbolic SBool-forSome = Trans.forSome+-- Remember that SBV assumes that the input is in prenex-normal form.+-- That is, all quantifiers are at the beginning of the predicate. See+-- [note on reasoning in the presence of+-- quantifiers]("Data.SBV#noteOnNested") for more information.+--+-- NB. For a version which generalizes over the underlying monad, see 'Data.SBV.Trans.existential'+existential :: Provable a => [String] -> a -> Symbolic SBool+existential = Trans.existential  -- | Prove a predicate, using the default solver. --@@ -267,15 +286,15 @@  -- | Create a user named input (universal) ----- NB. For a version which generalizes over the underlying monad, see 'Data.SBV.Trans.forall'-forall :: SymVal a => String -> Symbolic (SBV a)-forall = Trans.forall+-- NB. For a version which generalizes over the underlying monad, see 'Data.SBV.Trans.sbvForall'+sbvForall :: SymVal a => String -> Symbolic (SBV a)+sbvForall = Trans.sbvForall  -- | Create an automatically named input ----- NB. For a version which generalizes over the underlying monad, see 'Data.SBV.Trans.forall_'-forall_ :: SymVal a => Symbolic (SBV a)-forall_ = Trans.forall_+-- NB. For a version which generalizes over the underlying monad, see 'Data.SBV.Trans.sbvForall_'+sbvForall_ :: SymVal a => Symbolic (SBV a)+sbvForall_ = Trans.sbvForall_  -- | Get a bunch of new words --@@ -285,15 +304,15 @@  -- | Create an existential variable ----- NB. For a version which generalizes over the underlying monad, see 'Data.SBV.Trans.exists'-exists :: SymVal a => String -> Symbolic (SBV a)-exists = Trans.exists+-- NB. For a version which generalizes over the underlying monad, see 'Data.SBV.Trans.sbvExists'+sbvExists :: SymVal a => String -> Symbolic (SBV a)+sbvExists = Trans.sbvExists  -- | Create an automatically named existential variable ----- NB. For a version which generalizes over the underlying monad, see 'Data.SBV.Trans.exists_'-exists_ :: SymVal a => Symbolic (SBV a)-exists_ = Trans.exists_+-- NB. For a version which generalizes over the underlying monad, see 'Data.SBV.Trans.sbvExists_'+sbvExists_ :: SymVal a => Symbolic (SBV a)+sbvExists_ = Trans.sbvExists_  -- | Create a bunch of existentials --@@ -417,7 +436,7 @@ sWord32 :: String -> Symbolic SWord32 sWord32 = Trans.sWord32 --- | Declare an unamed 'SWord32'+-- | Declare an unnamed 'SWord32' -- -- NB. For a version which generalizes over the underlying monad, see 'Data.SBV.Trans.sWord32_' sWord32_ :: Symbolic SWord32@@ -978,6 +997,7 @@    FromSized (SInt  32) = SInt32    FromSized (SInt  64) = SInt64 +-- | Capture the correspondence, in terms of a constraint type family FromSizedCstr (t :: Type) :: Constraint where    FromSizedCstr (WordN  8) = ()    FromSizedCstr (WordN 16) = ()@@ -1043,6 +1063,7 @@    ToSized SInt32  = SInt  32    ToSized SInt64  = SInt  64 +-- | Capture the correspondence in terms of a constraint type family ToSizedCstr (t :: Type) :: Constraint where    ToSizedCstr Word8   = ()    ToSizedCstr Word16  = ()
Data/SBV/Compilers/C.hs view
@@ -12,7 +12,7 @@ {-# LANGUAGE CPP           #-} {-# LANGUAGE PatternGuards #-} -{-# OPTIONS_GHC -Wall -Werror #-}+{-# OPTIONS_GHC -Wall -Werror -Wno-incomplete-uni-patterns #-}  module Data.SBV.Compilers.C(compileToC, compileToCLib, compileToC', compileToCLib') where
Data/SBV/Compilers/CodeGen.hs view
@@ -262,7 +262,7 @@  -- | Creates an atomic input in the generated code. cgInput :: SymVal a => String -> SBVCodeGen (SBV a)-cgInput nm = do r <- forall_+cgInput nm = do r <- sbvForall_                 sv <- sbvToSymSV r                 modify' (\s -> s { cgInputs = (nm, CgAtomic sv) : cgInputs s })                 return r@@ -271,7 +271,7 @@ cgInputArr :: SymVal a => Int -> String -> SBVCodeGen [SBV a] cgInputArr sz nm   | sz < 1 = error $ "SBV.cgInputArr: Array inputs must have at least one element, given " ++ show sz ++ " for " ++ show nm-  | True   = do rs <- mapM (const forall_) [1..sz]+  | True   = do rs <- mapM (const sbvForall_) [1..sz]                 sws <- mapM sbvToSymSV rs                 modify' (\s -> s { cgInputs = (nm, CgArray sws) : cgInputs s })                 return rs
Data/SBV/Control/Utils.hs view
@@ -127,6 +127,11 @@                                              ]      | True                = send True $ setSMTOption o +   addSMTDefinition nm _ = error $ unlines [ ""+                                           , "*** Data.SBV: '" ++ show nm ++ "' must be defined in regular (non-query) mode."+                                           , "*** Hint: Define all functions before starting the query."+                                           ]+ -- | Adding a constraint, possibly with attributes and possibly soft. Only used internally. -- Use 'constrain' and 'namedConstraint' from user programs. addQueryConstraint :: (MonadIO m, MonadQuery m) => Bool -> [(String, String)] -> SBool -> m ()@@ -1100,12 +1105,17 @@                     walk (F.toList rObs) []  -- | Get UIs, both constants and functions. This call returns both the before and after query ones.--- | Generalization of 'Data.SBV.Control.getUIs'.+-- Generalization of 'Data.SBV.Control.getUIs'. Note that if we have an defined axiom, then it+-- is not really a UI, so we drop those. getUIs :: forall m. (MonadIO m, MonadQuery m) => m [(String, SBVType)]-getUIs = do State{rUIMap, rIncState} <- queryState+getUIs = do State{rUIMap, raxioms, rIncState} <- queryState+            -- NB. no need to worry about new-defines, because we don't allow definitions once query mode starts+            defines <- do allAxs <- io $ readIORef raxioms+                          pure [nm | (True, nm, _) <- allAxs]+             prior <- io $ readIORef rUIMap             new   <- io $ readIORef rIncState >>= readIORef . rNewUIs-            return $ nub $ sort $ Map.toList prior ++ Map.toList new+            return $ nub $ sort [p | p@(n, _) <- Map.toList prior ++ Map.toList new, n `notElem` defines]  -- | Return all satisfying models. getAllSatResult :: forall m. (MonadIO m, MonadQuery m, SolverContext m) => m AllSatResult@@ -1349,15 +1359,16 @@                                                        scope cur pres c = do                                                                 send True "(push 1)"                                                                 reject cur-                                                                sequence_ $ accept <$> pres+                                                                mapM_ accept pres                                                                 r <- c                                                                 send True "(pop 1)"                                                                 pure r                                                     forM_ [0 .. length terms - 1] $ \i -> do                                                         sc <- shouldContinue-                                                        when sc $ do let (pre, rest@(cur S.:<| _)) = S.splitAt i terms-                                                                     scope cur pre $ walk False rest+                                                        when sc $ do case S.splitAt i terms of+                                                                       (pre, rest@(cur S.:<| _)) -> scope cur pre $ walk False rest+                                                                       _                         -> error "Data.SBV.allSat: Impossible happened, ran out of terms!"           -- All sat loop. This is slower, as it implements the reject-the-previous model and loop around logic. But          -- it can handle uninterpreted sorts; so we keep it here as a fall-back.@@ -1679,8 +1690,8 @@      -- If we're doing an external query, then we cannot allow quantifiers to be present. Why?      -- Consider:      ---     --      issue = do x :: SBool <- forall_-     --                 y :: SBool <- exists_+     --      issue = do x :: SBool <- sbvForall_+     --                 y :: SBool <- sbvExists_      --                 constrain y      --                 query $ do checkSat      --                         (,) <$> getValue x <*> getValue y@@ -1781,7 +1792,7 @@         --                              return (a', av)         --         --        liftIO $ putStrLn $ "Got: " ++ show av-        --        -- constrain $ a .> literal av + 1      -- Cant' do this since we're "out" of query. Sigh.+        --        -- constrain $ a .> literal av + 1      -- Can't do this since we're "out" of query. Sigh.         --         --        bv <- query $ do constrain $ a .> literal av + 1         --                         _ <- checkSat
Data/SBV/Core/AlgReals.hs view
@@ -278,7 +278,8 @@         -- appropriately and shown as a string         f25 :: Integer -> [Integer] -> Maybe (Int, String)         f25 1 sofar = let (ts, fs)   = partition (== 2) sofar-                          [lts, lfs] = map length [ts, fs]+                          lts        = length ts+                          lfs        = length fs                           noOfZeros  = lts `max` lfs                       in Just (noOfZeros, show (abs (numerator r)  * factor ts fs))         f25 v sofar = let (q2, r2) = v `quotRem` 2
Data/SBV/Core/Data.hs view
@@ -48,7 +48,7 @@  , sbvToSV, sbvToSymSV, forceSVArg  , SBVExpr(..), newExpr  , cache, Cached, uncache, uncacheAI, HasKind(..)- , Op(..), PBOp(..), FPOp(..), StrOp(..), SeqOp(..), RegExp(..), NamedSymVar(..), getTableIndex+ , Op(..), PBOp(..), FPOp(..), StrOp(..), RegExOp(..), SeqOp(..), RegExp(..), NamedSymVar(..), getTableIndex  , SBVPgm(..), Symbolic, runSymbolic, State, getPathCondition, extendPathCondition  , inSMTMode, SBVRunMode(..), Kind(..), Outputtable(..), Result(..)  , SolverContext(..), internalVariable, internalConstraint, isCodeGenMode@@ -428,6 +428,10 @@    -- itself, to see whether it's actually well-formed or is sensible by any means.    -- A separate formalization of SMT-Lib would be very useful here.    addAxiom :: String -> [String] -> m ()+   -- | Add a user-defined SMTLib function. You should define the name given here as an uninterpreted+   -- value as well. SBV performs no checks on the SMTLib definition you give, so if it doesn't match+   -- the required type, or is malformed in any way, the call will fail at run-time.+   addSMTDefinition :: String -> [String] -> m ()    -- | Set a solver time-out value, in milli-seconds. This function    -- essentially translates to the SMTLib call @(set-info :timeout val)@,    -- and your backend solver may or may not support it! The amount given@@ -437,7 +441,7 @@    -- | Get the state associated with this context    contextState :: m State -   {-# MINIMAL constrain, softConstrain, namedConstraint, constrainWithAttribute, setOption, addAxiom, contextState #-}+   {-# MINIMAL constrain, softConstrain, namedConstraint, constrainWithAttribute, setOption, addAxiom, addSMTDefinition, contextState #-}     -- time-out, logic, and info are  simply options in our implementation, so default implementation suffices    setTimeOut t = setOption $ OptionKeyword ":timeout" [show t]@@ -508,8 +512,11 @@           k = constructUKind (undefined :: a)    default literal :: Show a => a -> SBV a-  literal x = let k@(KUserSort  _ conts) = kindOf x-                  sx                     = show x+  literal x = let k  = kindOf x+                  sx = show x+                  conts = case k of+                           KUserSort _ cts -> cts+                           _               -> Nothing                   mbIdx = case conts of                             Just xs -> sx `elemIndex` xs                             Nothing -> Nothing@@ -523,29 +530,29 @@     | Just i <- unliteral s = p i     | True                  = False -  -- | Generalization of 'Data.SBV.forall'-  forall :: MonadSymbolic m => String -> m (SBV a)-  forall = mkSymVal (NonQueryVar (Just ALL)) . Just+  -- | Generalization of 'Data.SBV.sbvForall'+  sbvForall :: MonadSymbolic m => String -> m (SBV a)+  sbvForall = mkSymVal (NonQueryVar (Just ALL)) . Just -  -- | Generalization of 'Data.SBV.forall_'-  forall_ :: MonadSymbolic m => m (SBV a)-  forall_ = mkSymVal (NonQueryVar (Just ALL)) Nothing+  -- | Generalization of 'Data.SBV.sbvForall_'+  sbvForall_ :: MonadSymbolic m => m (SBV a)+  sbvForall_ = mkSymVal (NonQueryVar (Just ALL)) Nothing    -- | Generalization of 'Data.SBV.mkForallVars'   mkForallVars :: MonadSymbolic m => Int -> m [SBV a]-  mkForallVars n = mapM (const forall_) [1 .. n]+  mkForallVars n = mapM (const sbvForall_) [1 .. n] -  -- | Generalization of 'Data.SBV.exists'-  exists :: MonadSymbolic m => String -> m (SBV a)-  exists = mkSymVal (NonQueryVar (Just EX)) . Just+  -- | Generalization of 'Data.SBV.sbvExists'+  sbvExists :: MonadSymbolic m => String -> m (SBV a)+  sbvExists = mkSymVal (NonQueryVar (Just EX)) . Just -  -- | Generalization of 'Data.SBV.exists_'-  exists_ :: MonadSymbolic m => m (SBV a)-  exists_ = mkSymVal (NonQueryVar (Just EX)) Nothing+  -- | Generalization of 'Data.SBV.sbvExists_'+  sbvExists_ :: MonadSymbolic m => m (SBV a)+  sbvExists_ = mkSymVal (NonQueryVar (Just EX)) Nothing    -- | Generalization of 'Data.SBV.mkExistVars'   mkExistVars :: MonadSymbolic m => Int -> m [SBV a]-  mkExistVars n = mapM (const exists_) [1 .. n]+  mkExistVars n = mapM (const sbvExists_) [1 .. n]    -- | Generalization of 'Data.SBV.free'   free :: MonadSymbolic m => String -> m (SBV a)
Data/SBV/Core/Floating.hs view
@@ -19,7 +19,7 @@ {-# LANGUAGE TypeOperators        #-} {-# LANGUAGE UndecidableInstances #-} -{-# OPTIONS_GHC -Wall -Werror -fno-warn-orphans #-}+{-# OPTIONS_GHC -Wall -Werror -fno-warn-orphans -Wno-incomplete-uni-patterns #-}  module Data.SBV.Core.Floating (          IEEEFloating(..), IEEEFloatConvertible(..)@@ -55,14 +55,6 @@  import Data.SBV.Core.Operations --- For doctest use only------ $setup--- >>> :set -XTypeApplications--- >>> :set -XRankNTypes--- >>> :set -XScopedTypeVariables--- >>> import Data.SBV.Provers.Prover (prove)- -- | A class of floating-point (IEEE754) operations, some of -- which behave differently based on rounding modes. Note that unless -- the rounding mode is concretely RoundNearestTiesToEven, we will@@ -173,81 +165,13 @@ -- | SDouble instance instance IEEEFloating Double --- | Capture convertability from/to FloatingPoint representations.------ Conversions to float: 'toSFloat' and 'toSDouble' simply return the--- nearest representable float from the given type based on the rounding--- mode provided. Similarly, 'toSFloatingPoint' converts to a generalized--- floating-point number with specified exponent and significand bith widths.------ Conversions from float: 'fromSFloat', 'fromSDouble', 'fromSFloatingPoint' functions do--- the reverse conversion. However some care is needed when given values--- that are not representable in the integral target domain. For instance,--- converting an 'SFloat' to an 'SInt8' is problematic. The rules are as follows:------ If the input value is a finite point and when rounded in the given rounding mode to an--- integral value lies within the target bounds, then that result is returned.--- (This is the regular interpretation of rounding in IEEE754.)------ Otherwise (i.e., if the integral value in the float or double domain) doesn't--- fit into the target type, then the result is unspecified. Note that if the input--- is @+oo@, @-oo@, or @NaN@, then the result is unspecified.------ Due to the unspecified nature of conversions, SBV will never constant fold--- conversions from floats to integral values. That is, you will always get a--- symbolic value as output. (Conversions from floats to other floats will be--- constant folded. Conversions from integral values to floats will also be--- constant folded.)------ Note that unspecified really means unspecified: In particular, SBV makes--- no guarantees about matching the behavior between what you might get in--- Haskell, via SMT-Lib, or the C-translation. If the input value is out-of-bounds--- as defined above, or is @NaN@ or @oo@ or @-oo@, then all bets are off. In particular--- C and SMTLib are decidedly undefine this case, though that doesn't mean they do the--- same thing! Same goes for Haskell, which seems to convert via Int64, but we do--- not model that behavior in SBV as it doesn't seem to be intentional nor well documented.------ You can check for @NaN@, @oo@ and @-oo@, using the predicates 'fpIsNaN', 'fpIsInfinite',--- and 'fpIsPositive', 'fpIsNegative' predicates, respectively; and do the proper conversion--- based on your needs. (0 is a good choice, as are min/max bounds of the target type.)------ Currently, SBV provides no predicates to check if a value would lie within range for a--- particular conversion task, as this depends on the rounding mode and the types involved--- and can be rather tricky to determine. (See <http://github.com/LeventErkok/sbv/issues/456>--- for a discussion of the issues involved.) In a future release, we hope to be able to--- provide underflow and overflow predicates for these conversions as well.+-- | Conversion to and from floats class SymVal a => IEEEFloatConvertible a where   -- | Convert from an IEEE74 single precision float.   fromSFloat :: SRoundingMode -> SFloat -> SBV a   fromSFloat = genericFromFloat    -- | Convert to an IEEE-754 Single-precision float.-  ---  -- >>> :{-  -- roundTrip :: forall a. (Eq a, IEEEFloatConvertible a) => SRoundingMode -> SBV a -> SBool-  -- roundTrip m x = fromSFloat m (toSFloat m x) .== x-  -- :}-  ---  -- >>> prove $ roundTrip @Int8-  -- Q.E.D.-  -- >>> prove $ roundTrip @Word8-  -- Q.E.D.-  -- >>> prove $ roundTrip @Int16-  -- Q.E.D.-  -- >>> prove $ roundTrip @Word16-  -- Q.E.D.-  -- >>> prove $ roundTrip @Int32-  -- Falsifiable. Counter-example:-  --   s0 = RoundTowardNegative :: RoundingMode-  --   s1 =           826336134 :: Int32-  ---  -- Note how we get a failure on `Int32`. The counter-example value is not representable exactly as a single precision float:-  ---  -- >>> toRational (826336134 :: Float)-  -- 826336128 % 1-  ---  -- Note how the numerator is different, it is off by 6. This is hardly surprising, since floats become sparser as-  -- the magnitude increases to be able to cover all the integer values representable.   toSFloat :: SRoundingMode -> SBV a -> SFloat    -- default definition if we have an integral like@@ -259,36 +183,6 @@   fromSDouble = genericFromFloat    -- | Convert to an IEEE-754 Double-precision float.-  ---  -- >>> :{-  -- roundTrip :: forall a. (Eq a, IEEEFloatConvertible a) => SRoundingMode -> SBV a -> SBool-  -- roundTrip m x = fromSDouble m (toSDouble m x) .== x-  -- :}-  ---  -- >>> prove $ roundTrip @Int8-  -- Q.E.D.-  -- >>> prove $ roundTrip @Word8-  -- Q.E.D.-  -- >>> prove $ roundTrip @Int16-  -- Q.E.D.-  -- >>> prove $ roundTrip @Word16-  -- Q.E.D.-  -- >>> prove $ roundTrip @Int32-  -- Q.E.D.-  -- >>> prove $ roundTrip @Word32-  -- Q.E.D.-  -- >>> prove $ roundTrip @Int64-  -- Falsifiable. Counter-example:-  --   s0 = RoundNearestTiesToEven :: RoundingMode-  --   s1 =   -2305879001039372796 :: Int64-  ---  -- Just like in the `SFloat` case, once we reach 64-bits, we no longer can exactly represent the-  -- integer value for all possible values:-  ---  -- >>>  toRational (-2305879001039372796 :: Double)-  -- (-2305879001039372800) % 1-  ---  -- In this case the numerator is off by 4.   toSDouble :: SRoundingMode -> SBV a -> SDouble    -- default definition if we have an integral like@@ -636,13 +530,7 @@ sFloatAsComparableSWord32 f = ite (fpIsNegativeZero f) (sFloatAsComparableSWord32 0) (fromBitsBE $ sNot sb : ite sb (map sNot rest) rest)   where (sb : rest) = blastBE $ sFloatAsSWord32 f --- | Inverse transformation to 'sFloatAsComparableSWord32'. Note that this isn't a perfect inverse, since @-0@ maps to @0@ and back to @0@.--- Otherwise, it's faithful:------ >>> prove  $ \x -> let f = sComparableSWord32AsSFloat x in fpIsNaN f .|| fpIsNegativeZero f .|| sFloatAsComparableSWord32 f .== x--- Q.E.D.--- >>> prove $ \x -> fpIsNegativeZero x .|| sComparableSWord32AsSFloat (sFloatAsComparableSWord32 x) `fpIsEqualObject` x--- Q.E.D.+-- | Inverse transformation to 'sFloatAsComparableSWord32'. sComparableSWord32AsSFloat :: SWord32 -> SFloat sComparableSWord32AsSFloat w = sWord32AsSFloat $ ite sb (fromBitsBE $ sFalse : rest) (fromBitsBE $ map sNot allBits)   where allBits@(sb : rest) = blastBE w@@ -657,11 +545,6 @@  -- | Inverse transformation to 'sDoubleAsComparableSWord64'. Note that this isn't a perfect inverse, since @-0@ maps to @0@ and back to @0@. -- Otherwise, it's faithful:------ >>> prove  $ \x -> let d = sComparableSWord64AsSDouble x in fpIsNaN d .|| fpIsNegativeZero d .|| sDoubleAsComparableSWord64 d .== x--- Q.E.D.--- >>> prove $ \x -> fpIsNegativeZero x .|| sComparableSWord64AsSDouble (sDoubleAsComparableSWord64 x) `fpIsEqualObject` x--- Q.E.D. sComparableSWord64AsSDouble :: SWord64 -> SDouble sComparableSWord64AsSDouble w = sWord64AsSDouble $ ite sb (fromBitsBE $ sFalse : rest) (fromBitsBE $ map sNot allBits)   where allBits@(sb : rest) = blastBE w@@ -743,11 +626,6 @@  -- | Inverse transformation to 'sFloatingPointAsComparableSWord'. Note that this isn't a perfect inverse, since @-0@ maps to @0@ and back to @0@. -- Otherwise, it's faithful:------ >>> prove  $ \x -> let d = sComparableSWordAsSFloatingPoint x in fpIsNaN d .|| fpIsNegativeZero d .|| sFloatingPointAsComparableSWord (d :: SFPHalf) .== x--- Q.E.D.--- >>> prove $ \x -> fpIsNegativeZero x .|| sComparableSWordAsSFloatingPoint (sFloatingPointAsComparableSWord x) `fpIsEqualObject` (x :: SFPHalf)--- Q.E.D. sComparableSWordAsSFloatingPoint :: forall eb sb. (KnownNat (eb + sb), BVIsNonZero (eb + sb), ValidFloat eb sb) => SWord (eb + sb) -> SFloatingPoint eb sb sComparableSWordAsSFloatingPoint w = sWordAsSFloatingPoint $ ite signBit (fromBitsBE $ sFalse : rest) (fromBitsBE $ map sNot allBits)   where allBits@(signBit : rest) = blastBE w
Data/SBV/Core/Model.hs view
@@ -21,12 +21,12 @@ {-# LANGUAGE TypeOperators        #-} {-# LANGUAGE UndecidableInstances #-} -{-# OPTIONS_GHC -Wall -Werror -fno-warn-orphans #-}+{-# OPTIONS_GHC -Wall -Werror -fno-warn-orphans -Wno-incomplete-uni-patterns #-}  module Data.SBV.Core.Model (     Mergeable(..), Equality(..), EqSymbolic(..), OrdSymbolic(..), SDivisible(..), Uninterpreted(..), Metric(..), minimize, maximize, assertWithPenalty, SIntegral, SFiniteBits(..)   , ite, iteLazy, sFromIntegral, sShiftLeft, sShiftRight, sRotateLeft, sBarrelRotateLeft, sRotateRight, sBarrelRotateRight, sSignedShiftArithRight, (.^)-  , oneIf, genVar, genVar_, forall, forall_, exists, exists_+  , oneIf, genVar, genVar_, sbvForall, sbvForall_, sbvExists, sbvExists_   , pbAtMost, pbAtLeast, pbExactly, pbLe, pbGe, pbEq, pbMutexed, pbStronglyMutexed   , sBool, sBool_, sBools, sWord8, sWord8_, sWord8s, sWord16, sWord16_, sWord16s, sWord32, sWord32_, sWord32s   , sWord64, sWord64_, sWord64s, sInt8, sInt8_, sInt8s, sInt16, sInt16_, sInt16s, sInt32, sInt32_, sInt32s, sInt64, sInt64_@@ -90,7 +90,8 @@ import Data.SBV.Provers.Prover (defaultSMTCfg, SafeResult(..), prove) import Data.SBV.SMT.SMT        (ThmResult, showModel) -import Data.SBV.Utils.Lib      (isKString)+import Data.SBV.Utils.Lib     (isKString)+import Data.SBV.Utils.Numeric (fpIsEqualObjectH)  -- Symbolic-Word class instances @@ -803,13 +804,6 @@   -- | Returns (symbolic) `sTrue` if all the elements of the given list are different. The second   -- list contains exceptions, i.e., if an element belongs to that set, it will be considered   -- distinct regardless of repetition.-  ---  -- >>> prove $ \a -> distinctExcept [a, a] [0::SInteger] .<=> a .== 0-  -- Q.E.D.-  -- >>> prove $ \a b -> distinctExcept [a, b] [0::SWord8] .<=> (a .== b .=> a .== 0)-  -- Q.E.D.-  -- >>> prove $ \a b c d -> distinctExcept [a, b, c, d] [] .== distinct [a, b, c, (d::SInteger)]-  -- Q.E.D.   distinctExcept :: [a] -> [a] -> SBool    -- | Returns (symbolic) 'sTrue' if all the elements of the given list are the same.@@ -1089,6 +1083,17 @@   (a0, b0, c0, d0, e0, f0, g0) .< (a1, b1, c1, d1, e1, f1, g1) =    (a0, b0, c0, d0, e0, f0) .<  (a1, b1, c1, d1, e1, f1)                                                                .|| ((a0, b0, c0, d0, e0, f0) .== (a1, b1, c1, d1, e1, f1) .&& g0 .< g1) +-- | Regular expressions can be compared for equality. Note that we diverge here from the equality+-- in the concrete sense; i.e., the Eq instance does not match the symbolic case. This is a bit unfortunate,+-- but unavoidable with the current design of how we "distinguish" operators. Hopefully shouldn't be a big deal,+-- though one should be careful.+instance EqSymbolic RegExp where+  r1 .== r2 = SBV $ SVal KBool $ Right $ cache r+    where r st = newExpr st KBool $ SBVApp (RegExOp (RegExEq r1 r2))  []++  r1 ./= r2 = SBV $ SVal KBool $ Right $ cache r+    where r st = newExpr st KBool $ SBVApp (RegExOp (RegExNEq r1 r2)) []+ -- | Symbolic Numbers. This is a simple class that simply incorporates all number like -- base types together, simplifying writing polymorphic type-signatures that work for all -- symbolic numbers, such as 'SWord8', 'SInt8' etc. For instance, we can write a generic@@ -1179,8 +1184,8 @@     -- seems a total overkill for most use cases. If such is required, users are encouraged     -- to define their own variants, which is rather easy.     sPopCount x-      | isConcrete x  = go 0 x-      | True          = sum [ite b 1 0 | b <- blastLE x]+      | Just v <- unliteral x = go 0 v+      | True                  = sum [ite b 1 0 | b <- blastLE x]       where -- concrete case             go !c 0 = c             go !c w = go (c+1) (w .&. (w-1))@@ -1636,9 +1641,6 @@ -- We provide this implementation as an alternative to `sRotateLeft` since SMTLib logic -- does not support variable argument rotates (as opposed to shifts), and thus this -- implementation can produce better code for verification compared to `sRotateLeft`.------ >>> prove $ \x y -> (x `sBarrelRotateLeft`  y) `sBarrelRotateRight` (y :: SWord32) .== (x :: SWord64)--- Q.E.D. sBarrelRotateLeft :: (SFiniteBits a, SFiniteBits b) => SBV a -> SBV b -> SBV a sBarrelRotateLeft = liftViaSVal svBarrelRotateLeft @@ -1650,9 +1652,6 @@  -- | An implementation of rotate-right, using a barrel shifter like design. See comments -- for `sBarrelRotateLeft` for details.------ >>> prove $ \x y -> (x `sBarrelRotateRight` y) `sBarrelRotateLeft`  (y :: SWord32) .== (x :: SWord64)--- Q.E.D. sBarrelRotateRight :: (SFiniteBits a, SFiniteBits b) => SBV a -> SBV b -> SBV a sBarrelRotateRight = liftViaSVal svBarrelRotateRight @@ -2035,11 +2034,6 @@                                   -- NB. No need to worry here that the index might be < 0; as the SMTLib translation takes care of that automatically                                   newExpr st kElt (SBVApp (LkUp (idx, kInd, kElt, len) swi swe) []) --- Unit-instance Mergeable () where-   symbolicMerge _ _ _ _ = ()-   select _ _ _ = ()- -- | Construct a useful error message if we hit an unmergeable case. cannotMerge :: String -> String -> String -> a cannotMerge typ why hint = error $ unlines [ ""@@ -2051,6 +2045,14 @@                                            , "*** Hint: " ++ hint                                            ] +-- | Merge concrete values that can be checked for equality+concreteMerge :: Show a => String -> String -> (a -> a -> Bool) -> a -> a -> a+concreteMerge t st eq x y+  | x `eq` y = x+  | True     = cannotMerge t+                           ("Concrete values can only be merged when equal. Got: " ++ show x ++ " vs. " ++ show y)+                           ("Use an " ++ st ++ " field if the values can differ.")+ -- Mergeable instances for List/Maybe/Either/Array are useful, but can -- throw exceptions if there is no structural matching of the results -- It's a question whether we should really keep them..@@ -2206,6 +2208,22 @@                                                              )     where (as, bs, cs, ds, es, fs, gs) = unzip7 xs +-- Base types are mergeable so long as they are equal+instance Mergeable ()      where symbolicMerge _ _ = concreteMerge "()"      "()"        (==)+instance Mergeable Integer where symbolicMerge _ _ = concreteMerge "Integer" "SInteger"  (==)+instance Mergeable Bool    where symbolicMerge _ _ = concreteMerge "Bool"    "SBool"     (==)+instance Mergeable Char    where symbolicMerge _ _ = concreteMerge "Char"    "SChar"     (==)+instance Mergeable Float   where symbolicMerge _ _ = concreteMerge "Float"   "SFloat"    fpIsEqualObjectH+instance Mergeable Double  where symbolicMerge _ _ = concreteMerge "Double"  "SDouble"   fpIsEqualObjectH+instance Mergeable Word8   where symbolicMerge _ _ = concreteMerge "Word8"   "SWord8"    (==)+instance Mergeable Word16  where symbolicMerge _ _ = concreteMerge "Word16"  "SWord16"   (==)+instance Mergeable Word32  where symbolicMerge _ _ = concreteMerge "Word32"  "SWord32"   (==)+instance Mergeable Word64  where symbolicMerge _ _ = concreteMerge "Word64"  "SWord64"   (==)+instance Mergeable Int8    where symbolicMerge _ _ = concreteMerge "Int8"    "SInt8"     (==)+instance Mergeable Int16   where symbolicMerge _ _ = concreteMerge "Int16"   "SInt16"    (==)+instance Mergeable Int32   where symbolicMerge _ _ = concreteMerge "Int32"   "SInt32"    (==)+instance Mergeable Int64   where symbolicMerge _ _ = concreteMerge "Int64"   "SInt64"    (==)+ -- Arbitrary product types, using GHC.Generics -- -- NB: Because of the way GHC.Generics works, the implementation of@@ -2509,17 +2527,18 @@    softConstrain               (SBV c) = imposeConstraint True  []               c    namedConstraint        nm   (SBV c) = imposeConstraint False [(":named", nm)] c    constrainWithAttribute atts (SBV c) = imposeConstraint False atts             c-   addAxiom                            = addSymAxiom+   addAxiom                            = addSymAxiom False+   addSMTDefinition                    = addSymAxiom True    contextState                        = symbolicEnv     setOption o = addNewSMTOption  o  -- | Add an axiom. Only used internally, use `addAxiom` from user programs which works over -- both regular and query modes of usage.-addSymAxiom :: (SolverContext m, MonadIO m) => String -> [String] -> m ()-addSymAxiom nm ax = do+addSymAxiom :: (SolverContext m, MonadIO m) => Bool -> String -> [String] -> m ()+addSymAxiom hasDefinition nm ax = do         st <- contextState-        liftIO $ modifyState st raxioms ((nm, ax) :) (return ())+        liftIO $ modifyState st raxioms ((hasDefinition, nm, ax) :) (return ())  -- | Generalization of 'Data.SBV.assertWithPenalty' assertWithPenalty :: MonadSymbolic m => String -> SBool -> Penalty -> m ()
Data/SBV/Core/Operations.hs view
@@ -27,7 +27,7 @@   , svLessThan, svGreaterThan, svLessEq, svGreaterEq, svStructuralLessThan   , svAnd, svOr, svXOr, svNot   , svShl, svShr, svRol, svRor-  , svExtract, svJoin+  , svExtract, svJoin, svZeroExtend, svSignExtend   , svIte, svLazyIte, svSymbolicMerge   , svSelect   , svSign, svUnsign, svSetBit, svWordFromBE, svWordFromLE@@ -50,7 +50,7 @@   where  import Data.Bits (Bits(..))-import Data.List (genericIndex, genericLength, genericTake)+import Data.List (genericIndex, genericLength, genericTake, foldl')  import qualified Data.IORef         as R    (readIORef) import qualified Data.IntMap.Strict as IMap (size, insert)@@ -522,11 +522,21 @@  -- | Join two words, by concatenating svJoin :: SVal -> SVal -> SVal-svJoin x@(SVal (KBounded s i) a) y@(SVal (KBounded _ j) b)+svJoin x@(SVal (KBounded s i) a) y@(SVal (KBounded s' j) b)+  | s /= s'+  = error $ "svJoin: received differently signed values: " ++ show (x, y)   | i == 0 = y   | j == 0 = x   | Left (CV _ (CInteger m)) <- a, Left (CV _ (CInteger n)) <- b-  = SVal k (Left $! CV k (CInteger (m `shiftL` j .|. n)))+  = let val+         | s -- signed, arithmetic doesn't work; blast and come back+         = let xbits = [m `testBit` xi | xi <- [0 .. i-1]]+               ybits = [n `testBit` yi | yi <- [0 .. j-1]]+               rbits = zip [0..] (ybits ++ xbits)+           in foldl' (\acc (idx, set) -> if set then setBit acc idx else acc) 0 rbits+         | True -- unsigned, go fast+         = m `shiftL` j .|. n+    in SVal k (Left $! normCV (CV k (CInteger val)))   | True   = SVal k (Right (cache z))   where@@ -535,6 +545,37 @@               ysw <- svToSV st y               newExpr st k (SBVApp Join [xsw, ysw]) svJoin _ _ = error "svJoin: non-bitvector type"++-- | Zero-extend by given number of bits.+svZeroExtend :: Int -> SVal -> SVal+svZeroExtend = svExtend True ZeroExtend++-- | Sign-extend by given number of bits.+svSignExtend :: Int -> SVal -> SVal+svSignExtend = svExtend False SignExtend++svExtend :: Bool -> (Int -> Op) -> Int -> SVal -> SVal+svExtend isZeroExtend extender i x@(SVal (KBounded s sz) a)+  | i < 0+  = error $ "svExtend: Received negative extension amount: " ++ show i+  | i == 0+  = x+  | Left (CV _ (CInteger cv)) <- a+  = SVal k' (Left (normCV (CV k' (CInteger (replBit (not isZeroExtend && (cv `testBit` (sz-1))) cv)))))+  | True+  = SVal k' (Right (cache z))+  where k' = KBounded s (sz+i)+        z st = do xsw <- svToSV st x+                  newExpr st k' (SBVApp (extender i) [xsw])++        replBit :: Bool -> Integer -> Integer+        replBit b = go sz+          where stop = sz + i+                go k v | k == stop = v+                       | b         = go (k+1) (v `setBit`   k)+                       | True      = go (k+1) (v `clearBit` k)++svExtend _ _ _ _ = error "svExtend: non-bitvector type"  -- | If-then-else. This one will force branches. svIte :: SVal -> SVal -> SVal -> SVal
Data/SBV/Core/Sized.hs view
@@ -27,8 +27,6 @@         , SInt, IntN, sInt, sInt_, sInts         -- * Bit-vector operations         , bvExtract, (#), zeroExtend, signExtend, bvDrop, bvTake-        -- * Splitting and reconstructing from bytes-        , ByteConverter(..)        ) where  import Data.Bits@@ -45,12 +43,6 @@  import Data.SBV.SMT.SMT --- Doctest only--- $setup--- >>> :set -XTypeApplications--- >>> :set -XDataKinds--- >>> import Data.SBV.Provers.Prover (prove)- -- | An unsigned bit-vector carrying its size info newtype WordN (n :: Nat) = WordN Integer deriving (Eq, Ord) @@ -95,7 +87,7 @@ lift1 :: (KnownNat n, BVIsNonZero n, HasKind (bv n), Integral (bv n), Show (bv n)) => String -> (SVal -> SVal) -> bv n -> bv n lift1 nm op x = uc $ op (c x)   where k = kindOf x-        c = SVal k . Left . CV k . CInteger . toInteger+        c = SVal k . Left . normCV . CV k . CInteger . toInteger         uc (SVal _ (Left (CV _ (CInteger v)))) = fromInteger v         uc r                                   = error $ "Impossible happened while lifting " ++ show nm ++ " over " ++ show (k, x, r) @@ -103,7 +95,7 @@ lift2 :: (KnownNat n, BVIsNonZero n, HasKind (bv n), Integral (bv n), Show (bv n)) => String -> (SVal -> SVal -> SVal) -> bv n -> bv n -> bv n lift2 nm op x y = uc $ c x `op` c y   where k = kindOf x-        c = SVal k . Left . CV k . CInteger . toInteger+        c = SVal k . Left . normCV . CV k . CInteger . toInteger         uc (SVal _ (Left (CV _ (CInteger v)))) = fromInteger v         uc r                                   = error $ "Impossible happened while lifting " ++ show nm ++ " over " ++ show (k, x, y, r) @@ -111,7 +103,7 @@ lift2I :: (KnownNat n, BVIsNonZero n, HasKind (bv n), Integral (bv n), Show (bv n)) => String -> (SVal -> Int -> SVal) -> bv n -> Int -> bv n lift2I nm op x i = uc $ c x `op` i   where k = kindOf x-        c = SVal k . Left . CV k . CInteger . toInteger+        c = SVal k . Left . normCV . CV k . CInteger . toInteger         uc (SVal _ (Left (CV _ (CInteger v)))) = fromInteger v         uc r                                   = error $ "Impossible happened while lifting " ++ show nm ++ " over " ++ show (k, x, i, r) @@ -119,7 +111,7 @@ lift2IB :: (KnownNat n, BVIsNonZero n, HasKind (bv n), Integral (bv n), Show (bv n)) => String -> (SVal -> Int -> SVal) -> bv n -> Int -> Bool lift2IB nm op x i = uc $ c x `op` i   where k = kindOf x-        c = SVal k . Left . CV k . CInteger . toInteger+        c = SVal k . Left . normCV . CV k . CInteger . toInteger         uc (SVal _ (Left v)) = cvToBool v         uc r                 = error $ "Impossible happened while lifting " ++ show nm ++ " over " ++ show (k, x, i, r) @@ -295,9 +287,6 @@ sInts = symbolics  -- | Extract a portion of bits to form a smaller bit-vector.------ >>> prove $ \x -> bvExtract (Proxy @7) (Proxy @3) (x :: SWord 12) .== bvDrop (Proxy @4) (bvTake (Proxy @9) x)--- Q.E.D. bvExtract :: forall i j n bv proxy. ( KnownNat n, BVIsNonZero n, SymVal (bv n)                                     , KnownNat i                                     , KnownNat j@@ -313,9 +302,6 @@          j  = fromIntegral (natVal end)  -- | Join two bitvectors.------ >>> prove $ \x y -> x .== bvExtract (Proxy @79) (Proxy @71) ((x :: SWord 9) # (y :: SWord 71))--- Q.E.D. (#) :: ( KnownNat n, BVIsNonZero n, SymVal (bv n)        , KnownNat m, BVIsNonZero m, SymVal (bv m)        ) => SBV (bv n)                     -- ^ First input, of size @n@, becomes the left side@@ -325,46 +311,33 @@ infixr 5 #  -- | Zero extend a bit-vector.------ >>> prove $ \x -> bvExtract (Proxy @20) (Proxy @12) (zeroExtend (x :: SInt 12) :: SInt 21) .== 0--- Q.E.D. zeroExtend :: forall n m bv. ( KnownNat n, BVIsNonZero n, SymVal (bv n)                              , KnownNat m, BVIsNonZero m, SymVal (bv m)                              , n + 1 <= m-                             , SIntegral (bv (m - n))+                             , SIntegral   (bv (m - n))                              , BVIsNonZero (m - n)                              ) => SBV (bv n)    -- ^ Input, of size @n@                                -> SBV (bv m)    -- ^ Output, of size @m@. @n < m@ must hold-zeroExtend n = SBV $ svJoin (unSBV zero) (unSBV n)-  where zero :: SBV (bv (m - n))-        zero = literal 0+zeroExtend n = SBV $ svZeroExtend i (unSBV n)+  where nv = intOfProxy (Proxy @n)+        mv = intOfProxy (Proxy @m)+        i  = fromIntegral (mv - nv)  -- | Sign extend a bit-vector.------ >>> prove $ \x -> sNot (msb x) .=> bvExtract (Proxy @20) (Proxy @12) (signExtend (x :: SInt 12) :: SInt 21) .== 0--- Q.E.D.--- >>> prove $ \x ->       msb x  .=> bvExtract (Proxy @20) (Proxy @12) (signExtend (x :: SInt 12) :: SInt 21) .== complement 0--- Q.E.D. signExtend :: forall n m bv. ( KnownNat n, BVIsNonZero n, SymVal (bv n)                              , KnownNat m, BVIsNonZero m, SymVal (bv m)                              , n + 1 <= m                              , SFiniteBits (bv n)                              , SIntegral   (bv (m - n))-                             , BVIsNonZero   (m - n)+                             , BVIsNonZero (m - n)                              ) => SBV (bv n)  -- ^ Input, of size @n@                                -> SBV (bv m)  -- ^ Output, of size @m@. @n < m@ must hold-signExtend n = SBV $ svJoin (unSBV ext) (unSBV n)-  where zero, ones, ext :: SBV (bv (m - n))-        zero = literal 0-        ones = complement zero-        ext  = ite (msb n) ones zero+signExtend n = SBV $ svSignExtend i (unSBV n)+  where nv = intOfProxy (Proxy @n)+        mv = intOfProxy (Proxy @m)+        i  = fromIntegral (mv - nv)  -- | Drop bits from the top of a bit-vector.------ >>> prove $ \x -> bvDrop (Proxy @0) (x :: SWord 43) .== x--- Q.E.D.--- >>> prove $ \x -> bvDrop (Proxy @20) (x :: SWord 21) .== ite (lsb x) 1 0--- Q.E.D. bvDrop :: forall i n m bv proxy. ( KnownNat n, BVIsNonZero n                                  , KnownNat i                                  , i + 1 <= n@@ -378,13 +351,6 @@         start = nv - fromIntegral (natVal i) - 1  -- | Take bits from the top of a bit-vector.------ >>> prove $ \x -> bvTake (Proxy @13) (x :: SWord 13) .== x--- Q.E.D.--- >>> prove $ \x -> bvTake (Proxy @1) (x :: SWord 13) .== ite (msb x) 1 0--- Q.E.D.--- >>> prove $ \x -> bvTake (Proxy @4) x # bvDrop (Proxy @4) x .== (x :: SWord 23)--- Q.E.D. bvTake :: forall i n bv proxy. ( KnownNat n, BVIsNonZero n                                , KnownNat i, BVIsNonZero i                                , i <= n@@ -395,170 +361,3 @@   where nv    = intOfProxy (Proxy @n)         start = nv - 1         end   = start - fromIntegral (natVal i) + 1---- | A helper class to convert sized bit-vectors to/from bytes.-class ByteConverter a where-   -- | Convert to a sequence of bytes-   ---   -- >>> prove $ \a b c d -> toBytes ((fromBytes [a, b, c, d]) :: SWord 32) .== [a, b, c, d]-   -- Q.E.D.-   toBytes   :: a -> [SWord 8]--   -- | Convert from a sequence of bytes-   ---   -- >>> prove $ \r -> fromBytes (toBytes r) .== (r :: SWord 64)-   -- Q.E.D.-   fromBytes :: [SWord 8] -> a---- NB. The following instances are automatically generated by buildUtils/genByteConverter.hs--- It is possible to write these more compactly indeed, but this explicit form generates--- better C code, and hence we allow the verbosity here.---- | 'SWord' 8 instance for 'ByteConverter'-instance ByteConverter (SWord 8) where-   toBytes a = [a]--   fromBytes [x] = x-   fromBytes as  = error $ "fromBytes:SWord 8: Incorrect number of bytes: " ++ show (length as)---- | 'SWord' 16 instance for 'ByteConverter'-instance ByteConverter (SWord 16) where-   toBytes a = [ bvExtract (Proxy @15) (Proxy  @8) a-               , bvExtract (Proxy  @7) (Proxy  @0) a-               ]--   fromBytes as-     | l == 2-     = (fromBytes :: [SWord 8] -> SWord 8) (take 1 as) # fromBytes (drop 1 as)-     | True-     = error $ "fromBytes:SWord 16: Incorrect number of bytes: " ++ show l-     where l = length as---- | 'SWord' 32 instance for 'ByteConverter'-instance ByteConverter (SWord 32) where-   toBytes a = [ bvExtract (Proxy @31) (Proxy @24) a, bvExtract (Proxy @23) (Proxy @16) a, bvExtract (Proxy @15) (Proxy  @8) a, bvExtract (Proxy  @7) (Proxy  @0) a-               ]--   fromBytes as-     | l == 4-     = (fromBytes :: [SWord 8] -> SWord 16) (take 2 as) # fromBytes (drop 2 as)-     | True-     = error $ "fromBytes:SWord 32: Incorrect number of bytes: " ++ show l-     where l = length as---- | 'SWord' 64 instance for 'ByteConverter'-instance ByteConverter (SWord 64) where-   toBytes a = [ bvExtract (Proxy @63) (Proxy @56) a, bvExtract (Proxy @55) (Proxy @48) a, bvExtract (Proxy @47) (Proxy @40) a, bvExtract (Proxy @39) (Proxy @32) a-               , bvExtract (Proxy @31) (Proxy @24) a, bvExtract (Proxy @23) (Proxy @16) a, bvExtract (Proxy @15) (Proxy  @8) a, bvExtract (Proxy  @7) (Proxy  @0) a-               ]--   fromBytes as-     | l == 8-     = (fromBytes :: [SWord 8] -> SWord 32) (take 4 as) # fromBytes (drop 4 as)-     | True-     = error $ "fromBytes:SWord 64: Incorrect number of bytes: " ++ show l-     where l = length as---- | 'SWord' 128 instance for 'ByteConverter'-instance ByteConverter (SWord 128) where-   toBytes a = [ bvExtract (Proxy @127) (Proxy @120) a, bvExtract (Proxy @119) (Proxy @112) a, bvExtract (Proxy @111) (Proxy @104) a, bvExtract (Proxy @103) (Proxy  @96) a-               , bvExtract (Proxy  @95) (Proxy  @88) a, bvExtract (Proxy  @87) (Proxy  @80) a, bvExtract (Proxy  @79) (Proxy  @72) a, bvExtract (Proxy  @71) (Proxy  @64) a-               , bvExtract (Proxy  @63) (Proxy  @56) a, bvExtract (Proxy  @55) (Proxy  @48) a, bvExtract (Proxy  @47) (Proxy  @40) a, bvExtract (Proxy  @39) (Proxy  @32) a-               , bvExtract (Proxy  @31) (Proxy  @24) a, bvExtract (Proxy  @23) (Proxy  @16) a, bvExtract (Proxy  @15) (Proxy   @8) a, bvExtract (Proxy   @7) (Proxy   @0) a-               ]--   fromBytes as-     | l == 16-     = (fromBytes :: [SWord 8] -> SWord 64) (take 8 as) # fromBytes (drop 8 as)-     | True-     = error $ "fromBytes:SWord 128: Incorrect number of bytes: " ++ show l-     where l = length as---- | 'SWord' 256 instance for 'ByteConverter'-instance ByteConverter (SWord 256) where-   toBytes a = [ bvExtract (Proxy @255) (Proxy @248) a, bvExtract (Proxy @247) (Proxy @240) a, bvExtract (Proxy @239) (Proxy @232) a, bvExtract (Proxy @231) (Proxy @224) a-               , bvExtract (Proxy @223) (Proxy @216) a, bvExtract (Proxy @215) (Proxy @208) a, bvExtract (Proxy @207) (Proxy @200) a, bvExtract (Proxy @199) (Proxy @192) a-               , bvExtract (Proxy @191) (Proxy @184) a, bvExtract (Proxy @183) (Proxy @176) a, bvExtract (Proxy @175) (Proxy @168) a, bvExtract (Proxy @167) (Proxy @160) a-               , bvExtract (Proxy @159) (Proxy @152) a, bvExtract (Proxy @151) (Proxy @144) a, bvExtract (Proxy @143) (Proxy @136) a, bvExtract (Proxy @135) (Proxy @128) a-               , bvExtract (Proxy @127) (Proxy @120) a, bvExtract (Proxy @119) (Proxy @112) a, bvExtract (Proxy @111) (Proxy @104) a, bvExtract (Proxy @103) (Proxy  @96) a-               , bvExtract (Proxy  @95) (Proxy  @88) a, bvExtract (Proxy  @87) (Proxy  @80) a, bvExtract (Proxy  @79) (Proxy  @72) a, bvExtract (Proxy  @71) (Proxy  @64) a-               , bvExtract (Proxy  @63) (Proxy  @56) a, bvExtract (Proxy  @55) (Proxy  @48) a, bvExtract (Proxy  @47) (Proxy  @40) a, bvExtract (Proxy  @39) (Proxy  @32) a-               , bvExtract (Proxy  @31) (Proxy  @24) a, bvExtract (Proxy  @23) (Proxy  @16) a, bvExtract (Proxy  @15) (Proxy   @8) a, bvExtract (Proxy   @7) (Proxy   @0) a-               ]--   fromBytes as-     | l == 32-     = (fromBytes :: [SWord 8] -> SWord 128) (take 16 as) # fromBytes (drop 16 as)-     | True-     = error $ "fromBytes:SWord 256: Incorrect number of bytes: " ++ show l-     where l = length as---- | 'SWord' 512 instance for 'ByteConverter'-instance ByteConverter (SWord 512) where-   toBytes a = [ bvExtract (Proxy @511) (Proxy @504) a, bvExtract (Proxy @503) (Proxy @496) a, bvExtract (Proxy @495) (Proxy @488) a, bvExtract (Proxy @487) (Proxy @480) a-               , bvExtract (Proxy @479) (Proxy @472) a, bvExtract (Proxy @471) (Proxy @464) a, bvExtract (Proxy @463) (Proxy @456) a, bvExtract (Proxy @455) (Proxy @448) a-               , bvExtract (Proxy @447) (Proxy @440) a, bvExtract (Proxy @439) (Proxy @432) a, bvExtract (Proxy @431) (Proxy @424) a, bvExtract (Proxy @423) (Proxy @416) a-               , bvExtract (Proxy @415) (Proxy @408) a, bvExtract (Proxy @407) (Proxy @400) a, bvExtract (Proxy @399) (Proxy @392) a, bvExtract (Proxy @391) (Proxy @384) a-               , bvExtract (Proxy @383) (Proxy @376) a, bvExtract (Proxy @375) (Proxy @368) a, bvExtract (Proxy @367) (Proxy @360) a, bvExtract (Proxy @359) (Proxy @352) a-               , bvExtract (Proxy @351) (Proxy @344) a, bvExtract (Proxy @343) (Proxy @336) a, bvExtract (Proxy @335) (Proxy @328) a, bvExtract (Proxy @327) (Proxy @320) a-               , bvExtract (Proxy @319) (Proxy @312) a, bvExtract (Proxy @311) (Proxy @304) a, bvExtract (Proxy @303) (Proxy @296) a, bvExtract (Proxy @295) (Proxy @288) a-               , bvExtract (Proxy @287) (Proxy @280) a, bvExtract (Proxy @279) (Proxy @272) a, bvExtract (Proxy @271) (Proxy @264) a, bvExtract (Proxy @263) (Proxy @256) a-               , bvExtract (Proxy @255) (Proxy @248) a, bvExtract (Proxy @247) (Proxy @240) a, bvExtract (Proxy @239) (Proxy @232) a, bvExtract (Proxy @231) (Proxy @224) a-               , bvExtract (Proxy @223) (Proxy @216) a, bvExtract (Proxy @215) (Proxy @208) a, bvExtract (Proxy @207) (Proxy @200) a, bvExtract (Proxy @199) (Proxy @192) a-               , bvExtract (Proxy @191) (Proxy @184) a, bvExtract (Proxy @183) (Proxy @176) a, bvExtract (Proxy @175) (Proxy @168) a, bvExtract (Proxy @167) (Proxy @160) a-               , bvExtract (Proxy @159) (Proxy @152) a, bvExtract (Proxy @151) (Proxy @144) a, bvExtract (Proxy @143) (Proxy @136) a, bvExtract (Proxy @135) (Proxy @128) a-               , bvExtract (Proxy @127) (Proxy @120) a, bvExtract (Proxy @119) (Proxy @112) a, bvExtract (Proxy @111) (Proxy @104) a, bvExtract (Proxy @103) (Proxy  @96) a-               , bvExtract (Proxy  @95) (Proxy  @88) a, bvExtract (Proxy  @87) (Proxy  @80) a, bvExtract (Proxy  @79) (Proxy  @72) a, bvExtract (Proxy  @71) (Proxy  @64) a-               , bvExtract (Proxy  @63) (Proxy  @56) a, bvExtract (Proxy  @55) (Proxy  @48) a, bvExtract (Proxy  @47) (Proxy  @40) a, bvExtract (Proxy  @39) (Proxy  @32) a-               , bvExtract (Proxy  @31) (Proxy  @24) a, bvExtract (Proxy  @23) (Proxy  @16) a, bvExtract (Proxy  @15) (Proxy   @8) a, bvExtract (Proxy   @7) (Proxy   @0) a-               ]--   fromBytes as-     | l == 64-     = (fromBytes :: [SWord 8] -> SWord 256) (take 32 as) # fromBytes (drop 32 as)-     | True-     = error $ "fromBytes:SWord 512: Incorrect number of bytes: " ++ show l-     where l = length as---- | 'SWord' 1024 instance for 'ByteConverter'-instance ByteConverter (SWord 1024) where-   toBytes a = [ bvExtract (Proxy @1023) (Proxy @1016) a, bvExtract (Proxy @1015) (Proxy @1008) a, bvExtract (Proxy @1007) (Proxy @1000) a, bvExtract (Proxy  @999) (Proxy  @992) a-               , bvExtract (Proxy  @991) (Proxy  @984) a, bvExtract (Proxy  @983) (Proxy  @976) a, bvExtract (Proxy  @975) (Proxy  @968) a, bvExtract (Proxy  @967) (Proxy  @960) a-               , bvExtract (Proxy  @959) (Proxy  @952) a, bvExtract (Proxy  @951) (Proxy  @944) a, bvExtract (Proxy  @943) (Proxy  @936) a, bvExtract (Proxy  @935) (Proxy  @928) a-               , bvExtract (Proxy  @927) (Proxy  @920) a, bvExtract (Proxy  @919) (Proxy  @912) a, bvExtract (Proxy  @911) (Proxy  @904) a, bvExtract (Proxy  @903) (Proxy  @896) a-               , bvExtract (Proxy  @895) (Proxy  @888) a, bvExtract (Proxy  @887) (Proxy  @880) a, bvExtract (Proxy  @879) (Proxy  @872) a, bvExtract (Proxy  @871) (Proxy  @864) a-               , bvExtract (Proxy  @863) (Proxy  @856) a, bvExtract (Proxy  @855) (Proxy  @848) a, bvExtract (Proxy  @847) (Proxy  @840) a, bvExtract (Proxy  @839) (Proxy  @832) a-               , bvExtract (Proxy  @831) (Proxy  @824) a, bvExtract (Proxy  @823) (Proxy  @816) a, bvExtract (Proxy  @815) (Proxy  @808) a, bvExtract (Proxy  @807) (Proxy  @800) a-               , bvExtract (Proxy  @799) (Proxy  @792) a, bvExtract (Proxy  @791) (Proxy  @784) a, bvExtract (Proxy  @783) (Proxy  @776) a, bvExtract (Proxy  @775) (Proxy  @768) a-               , bvExtract (Proxy  @767) (Proxy  @760) a, bvExtract (Proxy  @759) (Proxy  @752) a, bvExtract (Proxy  @751) (Proxy  @744) a, bvExtract (Proxy  @743) (Proxy  @736) a-               , bvExtract (Proxy  @735) (Proxy  @728) a, bvExtract (Proxy  @727) (Proxy  @720) a, bvExtract (Proxy  @719) (Proxy  @712) a, bvExtract (Proxy  @711) (Proxy  @704) a-               , bvExtract (Proxy  @703) (Proxy  @696) a, bvExtract (Proxy  @695) (Proxy  @688) a, bvExtract (Proxy  @687) (Proxy  @680) a, bvExtract (Proxy  @679) (Proxy  @672) a-               , bvExtract (Proxy  @671) (Proxy  @664) a, bvExtract (Proxy  @663) (Proxy  @656) a, bvExtract (Proxy  @655) (Proxy  @648) a, bvExtract (Proxy  @647) (Proxy  @640) a-               , bvExtract (Proxy  @639) (Proxy  @632) a, bvExtract (Proxy  @631) (Proxy  @624) a, bvExtract (Proxy  @623) (Proxy  @616) a, bvExtract (Proxy  @615) (Proxy  @608) a-               , bvExtract (Proxy  @607) (Proxy  @600) a, bvExtract (Proxy  @599) (Proxy  @592) a, bvExtract (Proxy  @591) (Proxy  @584) a, bvExtract (Proxy  @583) (Proxy  @576) a-               , bvExtract (Proxy  @575) (Proxy  @568) a, bvExtract (Proxy  @567) (Proxy  @560) a, bvExtract (Proxy  @559) (Proxy  @552) a, bvExtract (Proxy  @551) (Proxy  @544) a-               , bvExtract (Proxy  @543) (Proxy  @536) a, bvExtract (Proxy  @535) (Proxy  @528) a, bvExtract (Proxy  @527) (Proxy  @520) a, bvExtract (Proxy  @519) (Proxy  @512) a-               , bvExtract (Proxy  @511) (Proxy  @504) a, bvExtract (Proxy  @503) (Proxy  @496) a, bvExtract (Proxy  @495) (Proxy  @488) a, bvExtract (Proxy  @487) (Proxy  @480) a-               , bvExtract (Proxy  @479) (Proxy  @472) a, bvExtract (Proxy  @471) (Proxy  @464) a, bvExtract (Proxy  @463) (Proxy  @456) a, bvExtract (Proxy  @455) (Proxy  @448) a-               , bvExtract (Proxy  @447) (Proxy  @440) a, bvExtract (Proxy  @439) (Proxy  @432) a, bvExtract (Proxy  @431) (Proxy  @424) a, bvExtract (Proxy  @423) (Proxy  @416) a-               , bvExtract (Proxy  @415) (Proxy  @408) a, bvExtract (Proxy  @407) (Proxy  @400) a, bvExtract (Proxy  @399) (Proxy  @392) a, bvExtract (Proxy  @391) (Proxy  @384) a-               , bvExtract (Proxy  @383) (Proxy  @376) a, bvExtract (Proxy  @375) (Proxy  @368) a, bvExtract (Proxy  @367) (Proxy  @360) a, bvExtract (Proxy  @359) (Proxy  @352) a-               , bvExtract (Proxy  @351) (Proxy  @344) a, bvExtract (Proxy  @343) (Proxy  @336) a, bvExtract (Proxy  @335) (Proxy  @328) a, bvExtract (Proxy  @327) (Proxy  @320) a-               , bvExtract (Proxy  @319) (Proxy  @312) a, bvExtract (Proxy  @311) (Proxy  @304) a, bvExtract (Proxy  @303) (Proxy  @296) a, bvExtract (Proxy  @295) (Proxy  @288) a-               , bvExtract (Proxy  @287) (Proxy  @280) a, bvExtract (Proxy  @279) (Proxy  @272) a, bvExtract (Proxy  @271) (Proxy  @264) a, bvExtract (Proxy  @263) (Proxy  @256) a-               , bvExtract (Proxy  @255) (Proxy  @248) a, bvExtract (Proxy  @247) (Proxy  @240) a, bvExtract (Proxy  @239) (Proxy  @232) a, bvExtract (Proxy  @231) (Proxy  @224) a-               , bvExtract (Proxy  @223) (Proxy  @216) a, bvExtract (Proxy  @215) (Proxy  @208) a, bvExtract (Proxy  @207) (Proxy  @200) a, bvExtract (Proxy  @199) (Proxy  @192) a-               , bvExtract (Proxy  @191) (Proxy  @184) a, bvExtract (Proxy  @183) (Proxy  @176) a, bvExtract (Proxy  @175) (Proxy  @168) a, bvExtract (Proxy  @167) (Proxy  @160) a-               , bvExtract (Proxy  @159) (Proxy  @152) a, bvExtract (Proxy  @151) (Proxy  @144) a, bvExtract (Proxy  @143) (Proxy  @136) a, bvExtract (Proxy  @135) (Proxy  @128) a-               , bvExtract (Proxy  @127) (Proxy  @120) a, bvExtract (Proxy  @119) (Proxy  @112) a, bvExtract (Proxy  @111) (Proxy  @104) a, bvExtract (Proxy  @103) (Proxy   @96) a-               , bvExtract (Proxy   @95) (Proxy   @88) a, bvExtract (Proxy   @87) (Proxy   @80) a, bvExtract (Proxy   @79) (Proxy   @72) a, bvExtract (Proxy   @71) (Proxy   @64) a-               , bvExtract (Proxy   @63) (Proxy   @56) a, bvExtract (Proxy   @55) (Proxy   @48) a, bvExtract (Proxy   @47) (Proxy   @40) a, bvExtract (Proxy   @39) (Proxy   @32) a-               , bvExtract (Proxy   @31) (Proxy   @24) a, bvExtract (Proxy   @23) (Proxy   @16) a, bvExtract (Proxy   @15) (Proxy    @8) a, bvExtract (Proxy    @7) (Proxy    @0) a-               ]--   fromBytes as-     | l == 128-     = (fromBytes :: [SWord 8] -> SWord 512) (take 64 as) # fromBytes (drop 64 as)-     | True-     = error $ "fromBytes:SWord 1024: Incorrect number of bytes: " ++ show l-     where l = length as
Data/SBV/Core/SizedFloats.hs view
@@ -189,8 +189,7 @@         as x = "(_ " ++ x ++ " " ++ e ++ " " ++ s ++ ")" -       mkB sz val = "#b" ++ pad sz (showBin val "")-       showBin = showIntAtBase 2 intToDigit+       mkB sz val = "#b" ++ pad sz (showIntAtBase 2 intToDigit val "")        pad l str = replicate (l - length str) '0' ++ str  -- | Structural comparison only, for internal map indexes
Data/SBV/Core/Symbolic.hs view
@@ -34,7 +34,7 @@ module Data.SBV.Core.Symbolic   ( NodeId(..)   , SV(..), swKind, trueSV, falseSV-  , Op(..), PBOp(..), OvOp(..), FPOp(..), NROp(..), StrOp(..), SeqOp(..), SetOp(..)+  , Op(..), PBOp(..), OvOp(..), FPOp(..), NROp(..), StrOp(..), RegExOp(..), SeqOp(..), SetOp(..)   , RegExp(..), regExpToSMTString   , Quantifier(..), needsExistentials, VarContext(..)   , RoundingMode(..)@@ -185,6 +185,8 @@         | Ror Int         | Extract Int Int                       -- Extract i j: extract bits i to j. Least significant bit is 0 (big-endian)         | Join                                  -- Concat two words to form a bigger one, in the order given+        | ZeroExtend Int+        | SignExtend Int         | LkUp (Int, Kind, Kind, Int) !SV !SV   -- (table-index, arg-type, res-type, length of the table) index out-of-bounds-value         | ArrEq   ArrayIndex ArrayIndex         -- Array equality         | ArrRead ArrayIndex@@ -196,6 +198,7 @@         | OverflowOp    OvOp                    -- Overflow-ops, categorized separately         | PseudoBoolean PBOp                    -- Pseudo-boolean ops, categorized separately         | StrOp StrOp                           -- String ops, categorized separately+        | RegExOp RegExOp                       -- RegEx operations, categorized separately         | SeqOp SeqOp                           -- Sequence ops, categorized separately         | SetOp SetOp                           -- Set operations, categorized separately         | TupleConstructor Int                  -- Construct an n-tuple@@ -336,6 +339,11 @@            | StrInRe RegExp  -- ^ Check if string is in the regular expression            deriving (Eq, Ord, G.Data) +-- | Regular-expression operators. The only thing we can do is to compare for equality/disequality.+data RegExOp = RegExEq  RegExp RegExp+             | RegExNEq RegExp RegExp+             deriving (Eq, Ord, G.Data)+ -- | Regular expressions. Note that regular expressions themselves are -- concrete, but the 'Data.SBV.RegExp.match' function from the 'Data.SBV.RegExp.RegExpMatchable' class -- can check membership against a symbolic string/character. Also, we@@ -345,13 +353,17 @@ -- would like a parser for this type as it might be easier to use. data RegExp = Literal String       -- ^ Precisely match the given string             | All                  -- ^ Accept every string+            | AllChar              -- ^ Accept every single character             | None                 -- ^ Accept no strings             | Range Char Char      -- ^ Accept range of characters             | Conc  [RegExp]       -- ^ Concatenation             | KStar RegExp         -- ^ Kleene Star: Zero or more             | KPlus RegExp         -- ^ Kleene Plus: One or more             | Opt   RegExp         -- ^ Zero or one+            | Comp  RegExp         -- ^ Complement of regular expression+            | Diff  RegExp RegExp  -- ^ Difference of regular expressions             | Loop  Int Int RegExp -- ^ From @n@ repetitions to @m@ repetitions+            | Power Int     RegExp -- ^ Exactly @n@ repetitions, i.e., nth power             | Union [RegExp]       -- ^ Union of regular expressions             | Inter RegExp RegExp  -- ^ Intersection of regular expressions             deriving (Eq, Ord, G.Data)@@ -360,8 +372,10 @@ instance IsString RegExp where   fromString = Literal --- | Regular expressions as a 'Num' instance. Note that--- only `+` (union) and `*` (concatenation) make sense.+-- | Regular expressions as a 'Num' instance. Note that only some operations make sense and+-- not in the most obvious way. For instance, we would typically expect @a - b@ to be the+-- same as @a + negate b@, but that equality does not hold in general. So, use the @Num@+-- instance only as constructing syntax, not doing algebraic manipulations. instance Num RegExp where   -- flatten the concats to make them simpler   Conc xs * y = Conc (xs ++ [y])@@ -373,6 +387,8 @@   x + Union ys = Union (x  : ys)   x + y        = Union [x, y] +  x - y = Diff x y+   abs         = error "Num.RegExp: no abs method"   signum      = error "Num.RegExp: no signum method" @@ -381,7 +397,7 @@     | x == 1    = Literal ""   -- Unit for concatenation is the empty string     | True      = error $ "Num.RegExp: Only 0 and 1 makes sense as a reg-exp, no meaning for: " ++ show x -  negate      = error "Num.RegExp: no negate method"+  negate = Comp  -- | Convert a reg-exp to a Haskell-like string instance Show RegExp where@@ -394,7 +410,8 @@ -- | Convert a RegExp to a string, parameterized by how strings are converted regExpToString :: (String -> String) -> RegExp -> String regExpToString fs (Literal s)       = "(str.to.re " ++ fs s ++ ")"-regExpToString _  All               = "re.allchar"+regExpToString _  All               = "re.all"+regExpToString _  AllChar           = "re.allchar" regExpToString _  None              = "re.nostr" regExpToString fs (Range ch1 ch2)   = "(re.range " ++ fs [ch1] ++ " " ++ fs [ch2] ++ ")" regExpToString _  (Conc [])         = show (1 :: Integer)@@ -403,16 +420,20 @@ regExpToString fs (KStar r)         = "(re.* " ++ regExpToString fs r ++ ")" regExpToString fs (KPlus r)         = "(re.+ " ++ regExpToString fs r ++ ")" regExpToString fs (Opt   r)         = "(re.opt " ++ regExpToString fs r ++ ")"+regExpToString fs (Comp  r)         = "(re.comp " ++ regExpToString fs r ++ ")"+regExpToString fs (Diff  r1 r2)     = "(re.diff " ++ regExpToString fs r1 ++ " " ++ regExpToString fs r2 ++ ")" regExpToString fs (Loop  lo hi r)    | lo >= 0, hi >= lo = "((_ re.loop " ++ show lo ++ " " ++ show hi ++ ") " ++ regExpToString fs r ++ ")"    | True              = error $ "Invalid regular-expression Loop with arguments: " ++ show (lo, hi)+regExpToString fs (Power n r)+   | n >= 0            = regExpToString fs (Loop n n r)+   | True              = error $ "Invalid regular-expression Power with arguments: " ++ show n regExpToString fs (Inter r1 r2)     = "(re.inter " ++ regExpToString fs r1 ++ " " ++ regExpToString fs r2 ++ ")" regExpToString _  (Union [])        = "re.nostr" regExpToString fs (Union [x])       = regExpToString fs x regExpToString fs (Union xs)        = "(re.union " ++ unwords (map (regExpToString fs) xs) ++ ")" --- | Show instance for @StrOp@. Note that the mapping here is--- important to match the SMTLib equivalents, see here: <http://rise4fun.com/z3/tutorialcontent/sequences>+-- | Show instance for @StrOp@. Note that the mapping here is important to match the SMTLib equivalents. instance Show StrOp where   show StrConcat   = "str.++"   show StrLen      = "str.len"@@ -431,17 +452,23 @@   -- Note the breakage here with respect to argument order. We fix this explicitly later.   show (StrInRe s) = "str.in.re " ++ regExpToSMTString s +-- | Show instance for @RegExOp@.+instance Show RegExOp where+  show (RegExEq  r1 r2) = "(= "        ++ regExpToSMTString r1 ++ " " ++ regExpToSMTString r2 ++ ")"+  show (RegExNEq r1 r2) = "(distinct " ++ regExpToSMTString r1 ++ " " ++ regExpToSMTString r2 ++ ")"+ -- | Sequence operations.-data SeqOp = SeqConcat    -- ^ See StrConcat-           | SeqLen       -- ^ See StrLen-           | SeqUnit      -- ^ See StrUnit-           | SeqNth       -- ^ See StrNth-           | SeqSubseq    -- ^ See StrSubseq-           | SeqIndexOf   -- ^ See StrIndexOf-           | SeqContains  -- ^ See StrContains-           | SeqPrefixOf  -- ^ See StrPrefixOf-           | SeqSuffixOf  -- ^ See StrSuffixOf-           | SeqReplace   -- ^ See StrReplace+data SeqOp = SeqConcat        -- ^ See StrConcat+           | SeqLen           -- ^ See StrLen+           | SeqUnit          -- ^ See StrUnit+           | SeqNth           -- ^ See StrNth+           | SeqSubseq        -- ^ See StrSubseq+           | SeqIndexOf       -- ^ See StrIndexOf+           | SeqContains      -- ^ See StrContains+           | SeqPrefixOf      -- ^ See StrPrefixOf+           | SeqSuffixOf      -- ^ See StrSuffixOf+           | SeqReplace       -- ^ See StrReplace+           | SBVReverse Kind  -- ^ Reversal of sequences. NB. Also works for strings; hence the name.   deriving (Eq, Ord, G.Data)  -- | Show instance for SeqOp. Again, mapping is important.@@ -456,6 +483,8 @@   show SeqPrefixOf = "seq.prefixof"   show SeqSuffixOf = "seq.suffixof"   show SeqReplace  = "seq.replace"+  -- Note: This isn't part of SMTLib, we explicitly handle it+  show (SBVReverse k) = "sbv.reverse[" ++ show k ++ "]"  -- | Set operations. data SetOp = SetEqual@@ -516,6 +545,7 @@   show (OverflowOp o)       = show o    show (StrOp s)            = show s+  show (RegExOp s)          = show s   show (SeqOp s)            = show s   show (SetOp s)            = show s @@ -552,8 +582,7 @@                  , (Join, "#")                  ] --- | Quantifiers: forall or exists. Note that we allow--- arbitrary nestings.+-- | Quantifiers: forall or exists. Note that we allow arbitrary nestings. data Quantifier = ALL | EX deriving Eq  -- | Show instance for 'Quantifier'@@ -764,7 +793,7 @@                      , resTables      :: [((Int, Kind, Kind), [SV])]                  -- ^ tables (automatically constructed) (tableno, index-type, result-type) elts                      , resArrays      :: [(Int, ArrayInfo)]                           -- ^ arrays (user specified)                      , resUIConsts    :: [(String, SBVType)]                          -- ^ uninterpreted constants-                     , resAxioms      :: [(String, [String])]                         -- ^ axioms+                     , resAxioms      :: [(Bool, String, [String])]                   -- ^ axioms/definitions                      , resAsgns       :: SBVPgm                                       -- ^ assignments                      , resConstraints :: S.Seq (Bool, [(String, String)], SV)         -- ^ additional constraints (boolean)                      , resAssertions  :: [(String, Maybe CallStack, SV)]              -- ^ assertions@@ -839,7 +868,9 @@            shui (nm, t) = "  [uninterpreted] " ++ nm ++ " :: " ++ show t -          shax (nm, ss) = "  -- user defined axiom: " ++ nm ++ "\n  " ++ intercalate "\n  " ss+          shax (hasDefinition, nm, ss) = "  -- user defined " ++ what ++ ": " ++ nm ++ "\n  " ++ intercalate "\n  " ss+             where what | hasDefinition = "value"+                        | True          = "axiom"            shCstr (isSoft, [], c)               = soft isSoft ++ show c           shCstr (isSoft, [(":named", nm)], c) = soft isSoft ++ nm ++ ": " ++ show c@@ -1123,7 +1154,7 @@                     , rFArrayMap   :: IORef FArrayMap                     , rUIMap       :: IORef UIMap                     , rCgMap       :: IORef CgMap-                    , raxioms      :: IORef [(String, [String])]+                    , raxioms      :: IORef [(Bool, String, [String])]                     , rSMTOptions  :: IORef [SMTOption]                     , rOptGoals    :: IORef [Objective (SV, SV)]                     , rAsserts     :: IORef [(String, Maybe CallStack, SV)]@@ -1736,8 +1767,11 @@     tbls  <- map arrange . sortBy cmp . map swap . Map.toList <$> readIORef tables    arrs  <- IMap.toAscList <$> readIORef arrays-   unint <- Map.toList <$> readIORef uis    axs   <- reverse <$> readIORef axioms+   unint <- do unints <- Map.toList <$> readIORef uis+               -- drop those that has an axiom associated with it+               let defineds = [nm | (True, nm, _) <- axs]+               pure [ui | ui@(nm, _) <- unints, nm `notElem` defineds]    knds  <- readIORef usedKinds    cgMap <- Map.toList <$> readIORef cgs
Data/SBV/Dynamic.hs view
@@ -51,7 +51,7 @@   , svAnd, svOr, svXOr, svNot   , svShl, svShr, svRol, svRor   -- *** Splitting, joining, and extending-  , svExtract, svJoin+  , svExtract, svJoin, svZeroExtend, svSignExtend   -- *** Sign-casting   , svSign, svUnsign   -- *** Numeric conversions
Data/SBV/Either.hs view
@@ -35,11 +35,10 @@ import Data.SBV.Core.Data import Data.SBV.Core.Model () -- instances only --- For doctest use only--- -- $setup--- >>> import Data.SBV.Core.Model--- >>> import Data.SBV.Provers.Prover+-- >>> -- For doctest purposes only:+-- >>> import Prelude hiding(either)+-- >>> import Data.SBV  -- | Construct an @SEither a b@ from an @SBV a@ --
Data/SBV/Internals.hs view
@@ -17,6 +17,10 @@ -- is a very good but also a very difficult question to answer!) ----------------------------------------------------------------------------- +{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE Rank2Types       #-}+{-# LANGUAGE TypeOperators    #-}+ {-# OPTIONS_GHC -Wall -Werror #-}  module Data.SBV.Internals (@@ -60,13 +64,15 @@ import Control.Monad.IO.Class (MonadIO)  import Data.SBV.Core.Data+import Data.SBV.Core.Kind       (BVIsNonZero, ValidFloat)+import Data.SBV.Core.Sized      (SWord) import Data.SBV.Core.Model      (genLiteral, genFromCV, genMkSymVar, liftQRem, liftDMod) import Data.SBV.Core.Symbolic   (IStage(..), QueryContext(..), MonadQuery, addSValOptGoal, registerKind, VarContext(..), svToSV) -import Data.SBV.Core.Floating   ( sFloatAsComparableSWord32,  sDoubleAsComparableSWord64,  sFloatingPointAsComparableSWord-                                , sComparableSWord32AsSFloat, sComparableSWord64AsSDouble, sComparableSWordAsSFloatingPoint-                                )+import Data.SBV.Core.Floating   ( sFloatAsComparableSWord32,  sDoubleAsComparableSWord64,  sFloatingPointAsComparableSWord) +import qualified Data.SBV.Core.Floating as CF (sComparableSWord32AsSFloat, sComparableSWord64AsSDouble, sComparableSWordAsSFloatingPoint)+ import Data.SBV.Compilers.C       (compileToC', compileToCLib') import Data.SBV.Compilers.CodeGen @@ -77,8 +83,14 @@ import Data.SBV.Utils.TDiff import Data.SBV.Utils.PrettyNum +import GHC.TypeLits+ import qualified Data.SBV.Control.Utils as Query +--- $setup+--- >>> -- For doctest purposes only:+--- >>> import Data.SBV+ -- | Send an arbitrary string to the solver in a query. -- Note that this is inherently dangerous as it can put the solver in an arbitrary -- state and confuse SBV. If you use this feature, you are on your own!@@ -106,5 +118,35 @@ Similarly, the function 'retrieveResponseFromSolver' might occasionally be necessary to clean-up the communication buffer. We would like to hear if you do need these functions regularly so we can provide better support. -}++-- | Inverse transformation to 'sFloatAsComparableSWord32'. Note that this isn't a perfect inverse, since @-0@ maps to @0@ and back to @0@.+-- Otherwise, it's faithful:+--+-- >>> prove  $ \x -> let f = sComparableSWord32AsSFloat x in fpIsNaN f .|| fpIsNegativeZero f .|| sFloatAsComparableSWord32 f .== x+-- Q.E.D.+-- >>> prove $ \x -> fpIsNegativeZero x .|| sComparableSWord32AsSFloat (sFloatAsComparableSWord32 x) `fpIsEqualObject` x+-- Q.E.D.+sComparableSWord32AsSFloat :: SWord32 -> SFloat+sComparableSWord32AsSFloat = CF.sComparableSWord32AsSFloat ++-- | Inverse transformation to 'sDoubleAsComparableSWord64'. Note that this isn't a perfect inverse, since @-0@ maps to @0@ and back to @0@.+-- Otherwise, it's faithful:+--+-- >>> prove  $ \x -> let d = sComparableSWord64AsSDouble x in fpIsNaN d .|| fpIsNegativeZero d .|| sDoubleAsComparableSWord64 d .== x+-- Q.E.D.+-- >>> prove $ \x -> fpIsNegativeZero x .|| sComparableSWord64AsSDouble (sDoubleAsComparableSWord64 x) `fpIsEqualObject` x+-- Q.E.D.+sComparableSWord64AsSDouble :: SWord64 -> SDouble+sComparableSWord64AsSDouble = CF.sComparableSWord64AsSDouble ++-- | Inverse transformation to 'sFloatingPointAsComparableSWord'. Note that this isn't a perfect inverse, since @-0@ maps to @0@ and back to @0@.+-- Otherwise, it's faithful:+--+-- >>> prove  $ \x -> let d = sComparableSWordAsSFloatingPoint x in fpIsNaN d .|| fpIsNegativeZero d .|| sFloatingPointAsComparableSWord (d :: SFPHalf) .== x+-- Q.E.D.+-- >>> prove $ \x -> fpIsNegativeZero x .|| sComparableSWordAsSFloatingPoint (sFloatingPointAsComparableSWord x) `fpIsEqualObject` (x :: SFPHalf)+-- Q.E.D.+sComparableSWordAsSFloatingPoint :: forall eb sb. (KnownNat (eb + sb), BVIsNonZero (eb + sb), ValidFloat eb sb) => SWord (eb + sb) -> SFloatingPoint eb sb+sComparableSWordAsSFloatingPoint = CF.sComparableSWordAsSFloatingPoint  {-# ANN module ("HLint: ignore Use import/export shortcut" :: String) #-}
Data/SBV/List.hs view
@@ -25,14 +25,16 @@         -- * Length, emptiness           length, null         -- * Deconstructing/Reconstructing-        , head, tail, uncons, init, singleton, listToListAt, elemAt, (.!!), implode, concat, (.:), snoc, nil, (.++)+        , head, tail, uncons, init, singleton, listToListAt, elemAt, (!!), implode, concat, (.:), snoc, nil, (++)         -- * Containment         , elem, notElem, isInfixOf, isSuffixOf, isPrefixOf         -- * Sublists         , take, drop, subList, replace, indexOf, offsetIndexOf+        -- * Reverse+        , reverse         ) where -import Prelude hiding (head, tail, init, length, take, drop, concat, null, elem, notElem)+import Prelude hiding (head, tail, init, length, take, drop, concat, null, elem, notElem, reverse, (++), (!!)) import qualified Prelude as P  import Data.SBV.Core.Data hiding (StrOp(..))@@ -43,12 +45,10 @@  import Data.Proxy --- For doctest use only--- -- $setup--- >>> import Data.SBV.Provers.Prover (prove, sat)--- >>> import Data.Int--- >>> import Data.Word+-- >>> -- For doctest purposes only:+-- >>> import Prelude hiding (head, tail, init, length, take, drop, concat, null, elem, notElem, reverse, (++), (!!))+-- >>> import Data.SBV -- >>> :set -XOverloadedLists -- >>> :set -XScopedTypeVariables @@ -59,7 +59,7 @@ --   s0 = [0,0] :: [Word16] -- >>> sat $ \(l :: SList Word16) -> length l .< 0 -- Unsatisfiable--- >>> prove $ \(l1 :: SList Word16) (l2 :: SList Word16) -> length l1 + length l2 .== length (l1 .++ l2)+-- >>> prove $ \(l1 :: SList Word16) (l2 :: SList Word16) -> length l1 + length l2 .== length (l1 ++ l2) -- Q.E.D. length :: SymVal a => SList a -> SInteger length = lift1 SeqLen (Just (fromIntegral . P.length))@@ -86,11 +86,11 @@  -- | @`tail`@ returns the tail of a list. Unspecified if the list is empty. ----- >>> prove $ \(h :: SInteger) t -> tail (singleton h .++ t) .== t+-- >>> prove $ \(h :: SInteger) t -> tail (singleton h ++ t) .== t -- Q.E.D. -- >>> prove $ \(l :: SList Integer) -> length l .> 0 .=> length (tail l) .== length l - 1 -- Q.E.D.--- >>> prove $ \(l :: SList Integer) -> sNot (null l) .=> singleton (head l) .++ tail l .== l+-- >>> prove $ \(l :: SList Integer) -> sNot (null l) .=> singleton (head l) ++ tail l .== l -- Q.E.D. tail :: SymVal a => SList a -> SList a tail l@@ -105,7 +105,7 @@  -- | @`init`@ returns all but the last element of the list. Unspecified if the list is empty. ----- >>> prove $ \(h :: SInteger) t -> init (t .++ singleton h) .== t+-- >>> prove $ \(h :: SInteger) t -> init (t ++ singleton h) .== t -- Q.E.D. init :: SymVal a => SList a -> SList a init l@@ -126,11 +126,11 @@ -- | @`listToListAt` l offset@. List of length 1 at @offset@ in @l@. Unspecified if -- index is out of bounds. ----- >>> prove $ \(l1 :: SList Integer) l2 -> listToListAt (l1 .++ l2) (length l1) .== listToListAt l2 0+-- >>> prove $ \(l1 :: SList Integer) l2 -> listToListAt (l1 ++ l2) (length l1) .== listToListAt l2 0 -- Q.E.D. -- >>> sat $ \(l :: SList Word16) -> length l .>= 2 .&& listToListAt l 0 ./= listToListAt l (length l - 1) -- Satisfiable. Model:---   s0 = [0,2] :: [Word16]+--   s0 = [0,32] :: [Word16] listToListAt :: SymVal a => SList a -> SInteger -> SList a listToListAt s offset = subList s offset 1 @@ -150,8 +150,8 @@   = lift2 SeqNth Nothing l i  -- | Short cut for 'elemAt'-(.!!) :: SymVal a => SList a -> SInteger -> SBV a-(.!!) = elemAt+(!!) :: SymVal a => SList a -> SInteger -> SBV a+(!!) = elemAt  -- | @`implode` es@ is the list of length @|es|@ containing precisely those -- elements. Note that there is no corresponding function @explode@, since@@ -162,22 +162,22 @@ -- >>> prove $ \(e1 :: SInteger) e2 e3 -> map (elemAt (implode [e1, e2, e3])) (map literal [0 .. 2]) .== [e1, e2, e3] -- Q.E.D. implode :: SymVal a => [SBV a] -> SList a-implode = foldr ((.++) . singleton) (literal [])+implode = foldr ((++) . singleton) (literal []) --- | Concatenate two lists. See also `.++`.+-- | Concatenate two lists. See also `++`. concat :: SymVal a => SList a -> SList a -> SList a concat x y | isConcretelyEmpty x = y            | isConcretelyEmpty y = x-           | True                = lift2 SeqConcat (Just (++)) x y+           | True                = lift2 SeqConcat (Just (P.++)) x y  -- | Prepend an element, the traditional @cons@. infixr 5 .: (.:) :: SymVal a => SBV a -> SList a -> SList a-a .: as = singleton a .++ as+a .: as = singleton a ++ as  -- | Append an element snoc :: SymVal a => SList a -> SBV a -> SList a-as `snoc` a = as .++ singleton a+as `snoc` a = as ++ singleton a  -- | Empty list. This value has the property that it's the only list with length 0: --@@ -188,14 +188,14 @@  -- | Short cut for `concat`. ----- >>> sat $ \x y z -> length x .== 5 .&& length y .== 1 .&& x .++ y .++ z .== [1 .. 12]+-- >>> sat $ \x y z -> length x .== 5 .&& length y .== 1 .&& x ++ y ++ z .== [1 .. 12] -- Satisfiable. Model: --   s0 =      [1,2,3,4,5] :: [Integer] --   s1 =              [6] :: [Integer] --   s2 = [7,8,9,10,11,12] :: [Integer]-infixr 5 .++-(.++) :: SymVal a => SList a -> SList a -> SList a-(.++) = concat+infixr 5 +++(++) :: SymVal a => SList a -> SList a -> SList a+(++) = concat  -- | @`elem` e l@. Does @l@ contain the element @e@? elem :: (Eq a, SymVal a) => SBV a -> SList a -> SBool@@ -207,7 +207,7 @@  -- | @`isInfixOf` sub l@. Does @l@ contain the subsequence @sub@? ----- >>> prove $ \(l1 :: SList Integer) l2 l3 -> l2 `isInfixOf` (l1 .++ l2 .++ l3)+-- >>> prove $ \(l1 :: SList Integer) l2 l3 -> l2 `isInfixOf` (l1 ++ l2 ++ l3) -- Q.E.D. -- >>> prove $ \(l1 :: SList Integer) l2 -> l1 `isInfixOf` l2 .&& l2 `isInfixOf` l1 .<=> l1 .== l2 -- Q.E.D.@@ -220,7 +220,7 @@  -- | @`isPrefixOf` pre l@. Is @pre@ a prefix of @l@? ----- >>> prove $ \(l1 :: SList Integer) l2 -> l1 `isPrefixOf` (l1 .++ l2)+-- >>> prove $ \(l1 :: SList Integer) l2 -> l1 `isPrefixOf` (l1 ++ l2) -- Q.E.D. -- >>> prove $ \(l1 :: SList Integer) l2 -> l1 `isPrefixOf` l2 .=> subList l2 0 (length l1) .== l1 -- Q.E.D.@@ -233,7 +233,7 @@  -- | @`isSuffixOf` suf l@. Is @suf@ a suffix of @l@? ----- >>> prove $ \(l1 :: SList Word16) l2 -> l2 `isSuffixOf` (l1 .++ l2)+-- >>> prove $ \(l1 :: SList Word16) l2 -> l2 `isSuffixOf` (l1 ++ l2) -- Q.E.D. -- >>> prove $ \(l1 :: SList Word16) l2 -> l1 `isSuffixOf` l2 .=> subList l2 (length l2 - length l1) (length l1) .== l1 -- Q.E.D.@@ -257,7 +257,7 @@ -- -- >>> prove $ \(l :: SList Word16) i -> length (drop i l) .<= length l -- Q.E.D.--- >>> prove $ \(l :: SList Word16) i -> take i l .++ drop i l .== l+-- >>> prove $ \(l :: SList Word16) i -> take i l ++ drop i l .== l -- Q.E.D. drop :: SymVal a => SInteger -> SList a -> SList a drop i s = ite (i .>= ls) (literal [])@@ -269,7 +269,7 @@ -- This function is under-specified when the offset is outside the range of positions in @s@ or @len@ -- is negative or @offset+len@ exceeds the length of @s@. ----- >>> prove $ \(l :: SList Integer) i -> i .>= 0 .&& i .< length l .=> subList l 0 i .++ subList l i (length l - i) .== l+-- >>> prove $ \(l :: SList Integer) i -> i .>= 0 .&& i .< length l .=> subList l 0 i ++ subList l i (length l - i) .== l -- Q.E.D. -- >>> sat  $ \i j -> subList [1..5] i j .== ([2..4] :: SList Integer) -- Satisfiable. Model:@@ -300,7 +300,7 @@ replace :: (Eq a, SymVal a) => SList a -> SList a -> SList a -> SList a replace l src dst   | Just b <- unliteral src, P.null b   -- If src is null, simply prepend-  = dst .++ l+  = dst ++ l   | Just a <- unliteral l   , Just b <- unliteral src   , Just c <- unliteral dst@@ -310,7 +310,7 @@   where walk haystack needle newNeedle = go haystack   -- note that needle is guaranteed non-empty here.            where go []       = []                  go i@(c:cs)-                  | needle `L.isPrefixOf` i = newNeedle ++ genericDrop (genericLength needle :: Integer) i+                  | needle `L.isPrefixOf` i = newNeedle P.++ genericDrop (genericLength needle :: Integer) i                   | True                    = c : go cs  -- | @`indexOf` l sub@. Retrieves first position of @sub@ in @l@, @-1@ if there are no occurrences.@@ -344,6 +344,22 @@       _     -> -1   | True   = lift3 SeqIndexOf Nothing s sub offset++-- | @`reverse` s@ reverses the sequence.+-- >>> sat $ \(l :: SList Integer) -> reverse l .== literal [3, 2, 1]+-- Satisfiable. Model:+--   s0 = [1,2,3] :: [Integer]+-- >>> prove $ \(l :: SList Word32) -> reverse l .== [] .<=> null l+-- Q.E.D.+reverse :: SymVal a => SList a -> SList a+reverse l+  | Just l' <- unliteral l+  = literal (P.reverse l')+  | True+  = SBV $ SVal k $ Right $ cache r+  where k = kindOf l+        r st = do sva <- sbvToSV st l+                  newExpr st k (SBVApp (SeqOp (SBVReverse k)) [sva])  -- | Lift a unary operator over lists. lift1 :: forall a b. (SymVal a, SymVal b) => SeqOp -> Maybe (a -> b) -> SBV a -> SBV b
Data/SBV/Maybe.hs view
@@ -36,11 +36,10 @@ import Data.SBV.Core.Data import Data.SBV.Core.Model (ite) --- For doctest use only--- -- $setup--- >>> import Data.SBV.Core.Model--- >>> import Data.SBV.Provers.Prover+-- >>> -- For doctest purposes only:+-- >>> import Prelude hiding (maybe, map)+-- >>> import Data.SBV  -- | The symbolic 'Nothing'. --@@ -61,7 +60,7 @@  -- | Construct an @SMaybe a@ from an @SBV a@. ----- >>> sJust 3+-- >>> sJust (3 :: SInteger) -- Just 3 :: SMaybe Integer sJust :: forall a. SymVal a => SBV a -> SMaybe a sJust sa@@ -155,7 +154,7 @@  -- | Map over the 'Just' side of a 'Maybe'. ----- >>> prove $ \x -> fromJust (map (+1) (sJust x)) .== x+1+-- >>> prove $ \x -> fromJust (map (+1) (sJust x)) .== x+(1::SInteger) -- Q.E.D. -- >>> let f = uninterpret "f" :: SInteger -> SBool -- >>> prove $ \x -> map f (sJust x) .== sJust (f x)
Data/SBV/Provers/Prover.hs view
@@ -174,17 +174,17 @@ -- predicates can be constructed from almost arbitrary Haskell functions that have arbitrary -- shapes. (See the instance declarations below.) class ExtractIO m => MProvable m a where-  -- | Generalization of 'Data.SBV.forAll_'-  forAll_ :: a -> SymbolicT m SBool+  -- | Generalization of 'Data.SBV.universal_'+  universal_ :: a -> SymbolicT m SBool -  -- | Generalization of 'Data.SBV.forAll'-  forAll  :: [String] -> a -> SymbolicT m SBool+  -- | Generalization of 'Data.SBV.universal'+  universal  :: [String] -> a -> SymbolicT m SBool -  -- | Generalization of 'Data.SBV.forSome_'-  forSome_ :: a -> SymbolicT m SBool+  -- | Generalization of 'Data.SBV.existential_'+  existential_ :: a -> SymbolicT m SBool -  -- | Generalization of 'Data.SBV.forSome'-  forSome :: [String] -> a -> SymbolicT m SBool+  -- | Generalization of 'Data.SBV.existential'+  existential :: [String] -> a -> SymbolicT m SBool    -- | Generalization of 'Data.SBV.prove'   prove :: a -> m ThmResult@@ -364,7 +364,7 @@   -- | Generalization of 'Data.SBV.isVacuousWith'   isVacuousWith :: SMTConfig -> a -> m Bool   isVacuousWith cfg a = -- NB. Can't call runWithQuery since last constraint would become the implication!-       fst <$> runSymbolic (SMTMode QueryInternal ISetup True cfg) (forSome_ a >> Control.executeQuery QueryInternal check)+       fst <$> runSymbolic (SMTMode QueryInternal ISetup True cfg) (existential_ a >> Control.executeQuery QueryInternal check)      where        check :: QueryT m Bool        check = do cs <- Control.checkSat@@ -449,7 +449,7 @@                                 notify   "    We will assume that they are essentially zero for the purposes of validation."                                 notify   "    Note that this is a gross simplification of the model validation with universals!" -                         result <- snd <$> runSymbolic (Concrete (Just (isSAT, env))) ((if isSAT then forSome_ p else forAll_ p) >>= output)+                         result <- snd <$> runSymbolic (Concrete (Just (isSAT, env))) ((if isSAT then existential_ p else universal_ p) >>= output)                           let explain  = [ ""                                         , "Assignment:"  ++ if null env then " <none>" else ""@@ -625,7 +625,7 @@       let comments = ["Automatically created by SBV on " ++ show t]           cfg      = defaultSMTCfg { smtLibVersion = SMTLib2 } -      (_, res) <- runSymbolic (SMTMode QueryInternal ISetup isSat cfg) $ (if isSat then forSome_ else forAll_) a >>= output+      (_, res) <- runSymbolic (SMTMode QueryInternal ISetup isSat cfg) $ (if isSat then existential_ else universal_) a >>= output        let SMTProblem{smtLibPgm} = Control.runProofOn (SMTMode QueryInternal IRun isSat cfg) QueryInternal comments res           out                   = show (smtLibPgm cfg)@@ -644,24 +644,24 @@ -- If we get a program producing nothing (i.e., Symbolic ()), pretend it simply returns True. -- This is useful since min/max calls and constraints will provide the context instance ExtractIO m => MProvable m (SymbolicT m ()) where-  forAll_    a = forAll_    ((a >> return sTrue) :: SymbolicT m SBool)-  forAll ns  a = forAll ns  ((a >> return sTrue) :: SymbolicT m SBool)-  forSome_   a = forSome_   ((a >> return sTrue) :: SymbolicT m SBool)-  forSome ns a = forSome ns ((a >> return sTrue) :: SymbolicT m SBool)+  universal_     a = universal_     ((a >> return sTrue) :: SymbolicT m SBool)+  universal ns   a = universal ns   ((a >> return sTrue) :: SymbolicT m SBool)+  existential_   a = existential_   ((a >> return sTrue) :: SymbolicT m SBool)+  existential ns a = existential ns ((a >> return sTrue) :: SymbolicT m SBool)  instance ExtractIO m => MProvable m (SymbolicT m SBool) where-  forAll_    = id-  forAll []  = id-  forAll xs  = error $ "SBV.forAll: Extra unmapped name(s) in predicate construction: " ++ intercalate ", " xs-  forSome_   = id-  forSome [] = id-  forSome xs = error $ "SBV.forSome: Extra unmapped name(s) in predicate construction: " ++ intercalate ", " xs+  universal_     = id+  universal []   = id+  universal xs   = error $ "SBV.universal: Extra unmapped name(s) in predicate construction: " ++ intercalate ", " xs+  existential_   = id+  existential [] = id+  existential xs = error $ "SBV.existential: Extra unmapped name(s) in predicate construction: " ++ intercalate ", " xs  instance ExtractIO m => MProvable m SBool where-  forAll_   = return-  forAll _  = return-  forSome_  = return-  forSome _ = return+  universal_    = return+  universal _   = return+  existential_  = return+  existential _ = return  {- -- The following works, but it lets us write properties that@@ -669,83 +669,83 @@ -- Running that will throw an exception since Haskell's equality -- is not be supported by symbolic things. (Needs .==). instance Provable Bool where-  forAll_  x  = forAll_   (if x then true else false :: SBool)-  forAll s x  = forAll s  (if x then true else false :: SBool)-  forSome_  x = forSome_  (if x then true else false :: SBool)-  forSome s x = forSome s (if x then true else false :: SBool)+  universal_  x  = universal_     (if x then true else false :: SBool)+  universal s x  = universal s    (if x then true else false :: SBool)+  existential_  x = existential_  (if x then true else false :: SBool)+  existential s x = existential s (if x then true else false :: SBool) -}  -- Functions instance (SymVal a, MProvable m p) => MProvable m (SBV a -> p) where-  forAll_        k = forall_   >>= \a -> forAll_   $ k a-  forAll (s:ss)  k = forall s  >>= \a -> forAll ss $ k a-  forAll []      k = forAll_ k-  forSome_       k = exists_  >>= \a -> forSome_   $ k a-  forSome (s:ss) k = exists s >>= \a -> forSome ss $ k a-  forSome []     k = forSome_ k+  universal_         k = sbvForall_  >>= \a -> universal_   $ k a+  universal (s:ss)   k = sbvForall s >>= \a -> universal ss $ k a+  universal []       k = universal_ k+  existential_       k = sbvExists_  >>= \a -> existential_   $ k a+  existential (s:ss) k = sbvExists s >>= \a -> existential ss $ k a+  existential []     k = existential_ k  -- Arrays instance (HasKind a, HasKind b, MProvable m p) => MProvable m (SArray a b -> p) where-  forAll_        k = newArray_  Nothing >>= \a -> forAll_   $ k a-  forAll  (s:ss) k = newArray s Nothing >>= \a -> forAll ss $ k a-  forAll  []     k = forAll_ k-  forSome_       k = newArray_  Nothing >>= \a -> forSome_   $ k a-  forSome (s:ss) k = newArray s Nothing >>= \a -> forSome ss $ k a-  forSome []     k = forSome_ k+  universal_         k = newArray_  Nothing >>= \a -> universal_   $ k a+  universal  (s:ss)  k = newArray s Nothing >>= \a -> universal ss $ k a+  universal  []      k = universal_ k+  existential_       k = newArray_  Nothing >>= \a -> existential_   $ k a+  existential (s:ss) k = newArray s Nothing >>= \a -> existential ss $ k a+  existential []     k = existential_ k  -- 2 Tuple instance (SymVal a, SymVal b, MProvable m p) => MProvable m ((SBV a, SBV b) -> p) where-  forAll_        k = forall_  >>= \a -> forAll_   $ \b -> k (a, b)-  forAll (s:ss)  k = forall s >>= \a -> forAll ss $ \b -> k (a, b)-  forAll []      k = forAll_ k-  forSome_       k = exists_  >>= \a -> forSome_   $ \b -> k (a, b)-  forSome (s:ss) k = exists s >>= \a -> forSome ss $ \b -> k (a, b)-  forSome []     k = forSome_ k+  universal_         k = sbvForall_  >>= \a -> universal_   $ \b -> k (a, b)+  universal (s:ss)   k = sbvForall s >>= \a -> universal ss $ \b -> k (a, b)+  universal []       k = universal_ k+  existential_       k = sbvExists_  >>= \a -> existential_   $ \b -> k (a, b)+  existential (s:ss) k = sbvExists s >>= \a -> existential ss $ \b -> k (a, b)+  existential []     k = existential_ k  -- 3 Tuple instance (SymVal a, SymVal b, SymVal c, MProvable m p) => MProvable m ((SBV a, SBV b, SBV c) -> p) where-  forAll_       k  = forall_  >>= \a -> forAll_   $ \b c -> k (a, b, c)-  forAll (s:ss) k  = forall s >>= \a -> forAll ss $ \b c -> k (a, b, c)-  forAll []     k  = forAll_ k-  forSome_       k = exists_  >>= \a -> forSome_   $ \b c -> k (a, b, c)-  forSome (s:ss) k = exists s >>= \a -> forSome ss $ \b c -> k (a, b, c)-  forSome []     k = forSome_ k+  universal_         k = sbvForall_  >>= \a -> universal_   $ \b c -> k (a, b, c)+  universal (s:ss)   k = sbvForall s >>= \a -> universal ss $ \b c -> k (a, b, c)+  universal []       k = universal_ k+  existential_       k = sbvExists_  >>= \a -> existential_   $ \b c -> k (a, b, c)+  existential (s:ss) k = sbvExists s >>= \a -> existential ss $ \b c -> k (a, b, c)+  existential []     k = existential_ k  -- 4 Tuple instance (SymVal a, SymVal b, SymVal c, SymVal d, MProvable m p) => MProvable m ((SBV a, SBV b, SBV c, SBV d) -> p) where-  forAll_        k = forall_  >>= \a -> forAll_   $ \b c d -> k (a, b, c, d)-  forAll (s:ss)  k = forall s >>= \a -> forAll ss $ \b c d -> k (a, b, c, d)-  forAll []      k = forAll_ k-  forSome_       k = exists_  >>= \a -> forSome_   $ \b c d -> k (a, b, c, d)-  forSome (s:ss) k = exists s >>= \a -> forSome ss $ \b c d -> k (a, b, c, d)-  forSome []     k = forSome_ k+  universal_         k = sbvForall_  >>= \a -> universal_   $ \b c d -> k (a, b, c, d)+  universal (s:ss)   k = sbvForall s >>= \a -> universal ss $ \b c d -> k (a, b, c, d)+  universal []       k = universal_ k+  existential_       k = sbvExists_  >>= \a -> existential_   $ \b c d -> k (a, b, c, d)+  existential (s:ss) k = sbvExists s >>= \a -> existential ss $ \b c d -> k (a, b, c, d)+  existential []     k = existential_ k  -- 5 Tuple instance (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, MProvable m p) => MProvable m ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) where-  forAll_        k = forall_  >>= \a -> forAll_   $ \b c d e -> k (a, b, c, d, e)-  forAll (s:ss)  k = forall s >>= \a -> forAll ss $ \b c d e -> k (a, b, c, d, e)-  forAll []      k = forAll_ k-  forSome_       k = exists_  >>= \a -> forSome_   $ \b c d e -> k (a, b, c, d, e)-  forSome (s:ss) k = exists s >>= \a -> forSome ss $ \b c d e -> k (a, b, c, d, e)-  forSome []     k = forSome_ k+  universal_         k = sbvForall_  >>= \a -> universal_   $ \b c d e -> k (a, b, c, d, e)+  universal (s:ss)   k = sbvForall s >>= \a -> universal ss $ \b c d e -> k (a, b, c, d, e)+  universal []       k = universal_ k+  existential_       k = sbvExists_  >>= \a -> existential_   $ \b c d e -> k (a, b, c, d, e)+  existential (s:ss) k = sbvExists s >>= \a -> existential ss $ \b c d e -> k (a, b, c, d, e)+  existential []     k = existential_ k  -- 6 Tuple instance (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, SymVal f, MProvable m p) => MProvable m ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) where-  forAll_        k = forall_  >>= \a -> forAll_   $ \b c d e f -> k (a, b, c, d, e, f)-  forAll (s:ss)  k = forall s >>= \a -> forAll ss $ \b c d e f -> k (a, b, c, d, e, f)-  forAll []      k = forAll_ k-  forSome_       k = exists_  >>= \a -> forSome_   $ \b c d e f -> k (a, b, c, d, e, f)-  forSome (s:ss) k = exists s >>= \a -> forSome ss $ \b c d e f -> k (a, b, c, d, e, f)-  forSome []     k = forSome_ k+  universal_         k = sbvForall_  >>= \a -> universal_   $ \b c d e f -> k (a, b, c, d, e, f)+  universal (s:ss)   k = sbvForall s >>= \a -> universal ss $ \b c d e f -> k (a, b, c, d, e, f)+  universal []       k = universal_ k+  existential_       k = sbvExists_  >>= \a -> existential_   $ \b c d e f -> k (a, b, c, d, e, f)+  existential (s:ss) k = sbvExists s >>= \a -> existential ss $ \b c d e f -> k (a, b, c, d, e, f)+  existential []     k = existential_ k  -- 7 Tuple instance (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, SymVal f, SymVal g, MProvable m p) => MProvable m ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) where-  forAll_        k = forall_  >>= \a -> forAll_   $ \b c d e f g -> k (a, b, c, d, e, f, g)-  forAll (s:ss)  k = forall s >>= \a -> forAll ss $ \b c d e f g -> k (a, b, c, d, e, f, g)-  forAll []      k = forAll_ k-  forSome_       k = exists_  >>= \a -> forSome_   $ \b c d e f g -> k (a, b, c, d, e, f, g)-  forSome (s:ss) k = exists s >>= \a -> forSome ss $ \b c d e f g -> k (a, b, c, d, e, f, g)-  forSome []     k = forSome_ k+  universal_         k = sbvForall_  >>= \a -> universal_   $ \b c d e f g -> k (a, b, c, d, e, f, g)+  universal (s:ss)   k = sbvForall s >>= \a -> universal ss $ \b c d e f g -> k (a, b, c, d, e, f, g)+  universal []       k = universal_ k+  existential_       k = sbvExists_  >>= \a -> existential_   $ \b c d e f g -> k (a, b, c, d, e, f, g)+  existential (s:ss) k = sbvExists s >>= \a -> existential ss $ \b c d e f g -> k (a, b, c, d, e, f, g)+  existential []     k = existential_ k  -- | Generalization of 'Data.SBV.runSMT' runSMT :: MonadIO m => SymbolicT m a -> m a@@ -758,7 +758,7 @@ -- | Runs with a query. runWithQuery :: MProvable m a => Bool -> QueryT m b -> SMTConfig -> a -> m b runWithQuery isSAT q cfg a = fst <$> runSymbolic (SMTMode QueryInternal ISetup isSAT cfg) comp-  where comp =  do _ <- (if isSAT then forSome_ else forAll_) a >>= output+  where comp =  do _ <- (if isSAT then existential_ else universal_) a >>= output                    Control.executeQuery QueryInternal q  -- | Check if a safe-call was safe or not, turning a 'SafeResult' to a Bool.@@ -918,44 +918,44 @@  -- Functions instance (SymVal a, SExecutable m p) => SExecutable m (SBV a -> p) where-   sName_        k = exists_   >>= \a -> sName_   $ k a-   sName (s:ss)  k = exists s  >>= \a -> sName ss $ k a+   sName_        k = sbvExists_   >>= \a -> sName_   $ k a+   sName (s:ss)  k = sbvExists s  >>= \a -> sName ss $ k a    sName []      k = sName_ k  -- 2 Tuple input instance (SymVal a, SymVal b, SExecutable m p) => SExecutable m ((SBV a, SBV b) -> p) where-  sName_        k = exists_  >>= \a -> sName_   $ \b -> k (a, b)-  sName (s:ss)  k = exists s >>= \a -> sName ss $ \b -> k (a, b)+  sName_        k = sbvExists_  >>= \a -> sName_   $ \b -> k (a, b)+  sName (s:ss)  k = sbvExists s >>= \a -> sName ss $ \b -> k (a, b)   sName []      k = sName_ k  -- 3 Tuple input instance (SymVal a, SymVal b, SymVal c, SExecutable m p) => SExecutable m ((SBV a, SBV b, SBV c) -> p) where-  sName_       k  = exists_  >>= \a -> sName_   $ \b c -> k (a, b, c)-  sName (s:ss) k  = exists s >>= \a -> sName ss $ \b c -> k (a, b, c)+  sName_       k  = sbvExists_  >>= \a -> sName_   $ \b c -> k (a, b, c)+  sName (s:ss) k  = sbvExists s >>= \a -> sName ss $ \b c -> k (a, b, c)   sName []     k  = sName_ k  -- 4 Tuple input instance (SymVal a, SymVal b, SymVal c, SymVal d, SExecutable m p) => SExecutable m ((SBV a, SBV b, SBV c, SBV d) -> p) where-  sName_        k = exists_  >>= \a -> sName_   $ \b c d -> k (a, b, c, d)-  sName (s:ss)  k = exists s >>= \a -> sName ss $ \b c d -> k (a, b, c, d)+  sName_        k = sbvExists_  >>= \a -> sName_   $ \b c d -> k (a, b, c, d)+  sName (s:ss)  k = sbvExists s >>= \a -> sName ss $ \b c d -> k (a, b, c, d)   sName []      k = sName_ k  -- 5 Tuple input instance (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, SExecutable m p) => SExecutable m ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) where-  sName_        k = exists_  >>= \a -> sName_   $ \b c d e -> k (a, b, c, d, e)-  sName (s:ss)  k = exists s >>= \a -> sName ss $ \b c d e -> k (a, b, c, d, e)+  sName_        k = sbvExists_  >>= \a -> sName_   $ \b c d e -> k (a, b, c, d, e)+  sName (s:ss)  k = sbvExists s >>= \a -> sName ss $ \b c d e -> k (a, b, c, d, e)   sName []      k = sName_ k  -- 6 Tuple input instance (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, SymVal f, SExecutable m p) => SExecutable m ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) where-  sName_        k = exists_  >>= \a -> sName_   $ \b c d e f -> k (a, b, c, d, e, f)-  sName (s:ss)  k = exists s >>= \a -> sName ss $ \b c d e f -> k (a, b, c, d, e, f)+  sName_        k = sbvExists_  >>= \a -> sName_   $ \b c d e f -> k (a, b, c, d, e, f)+  sName (s:ss)  k = sbvExists s >>= \a -> sName ss $ \b c d e f -> k (a, b, c, d, e, f)   sName []      k = sName_ k  -- 7 Tuple input instance (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, SymVal f, SymVal g, SExecutable m p) => SExecutable m ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) where-  sName_        k = exists_  >>= \a -> sName_   $ \b c d e f g -> k (a, b, c, d, e, f, g)-  sName (s:ss)  k = exists s >>= \a -> sName ss $ \b c d e f g -> k (a, b, c, d, e, f, g)+  sName_        k = sbvExists_  >>= \a -> sName_   $ \b c d e f g -> k (a, b, c, d, e, f, g)+  sName (s:ss)  k = sbvExists s >>= \a -> sName ss $ \b c d e f g -> k (a, b, c, d, e, f, g)   sName []      k = sName_ k  {-# ANN module ("HLint: ignore Reduce duplication" :: String) #-}
Data/SBV/RegExp.hs view
@@ -24,11 +24,14 @@  module Data.SBV.RegExp (         -- * Regular expressions+        -- $regexpeq         RegExp(..)         -- * Matching         -- $matching         , RegExpMatchable(..)         -- * Constructing regular expressions+        -- ** Basics+        , everything, nothing, anyChar         -- ** Literals         , exactly         -- ** A class of characters@@ -63,12 +66,12 @@ -- For testing only import Data.SBV.Char --- For doctest use only--- -- $setup+-- >>> -- For doctest purposes only:+-- >>> import Data.SBV+-- >>> import Data.SBV.Char+-- >>> import Data.SBV.String -- >>> import Prelude hiding (length, take, elem, notElem, head)--- >>> import Data.SBV.Provers.Prover (prove, sat)--- >>> import Data.SBV.Core.Model -- >>> :set -XOverloadedStrings -- >>> :set -XScopedTypeVariables @@ -84,7 +87,7 @@ -- >>> let phone = pre * "-" * post -- >>> sat $ \s -> (s :: SString) `match` phone -- Satisfiable. Model:---   s0 = "386-3868" :: String+--   s0 = "200-8000" :: String class RegExpMatchable a where    -- | @`match` s r@ checks whether @s@ is in the language generated by @r@.    match :: a -> RegExp -> SBool@@ -100,6 +103,7 @@            go :: RegExp -> (String -> Bool) -> String -> Bool            go (Literal l)    k s      = l `L.isPrefixOf` s && k (P.drop (P.length l) s)            go All            _ _      = True+           go AllChar        k s      = not (P.null s) && k (P.drop 1 s)            go None           _ _      = False            go (Range _ _)    _ []     = False            go (Range a b)    k (c:cs) = a <= c && c <= b && k cs@@ -108,7 +112,10 @@            go (KStar r)      k s      = k s || go r (smaller (P.length s) (go (KStar r) k)) s            go (KPlus r)      k s      = go (Conc [r, KStar r]) k s            go (Opt r)        k s      = k s || go r k s-           go (Loop i j r)   k s      = go (Conc (replicate i r ++ replicate (j - i) (Opt r))) k s+           go (Comp r)       k s      = not $ go r k s+           go (Diff r1 r2)   k s      = go r1 k s && not (go r2 k s)+           go (Loop i j r)   k s      = go (Conc (replicate i r P.++ replicate (j - i) (Opt r))) k s+           go (Power n r)    k s      = go (Loop n n r) k s            go (Union [])     _ _      = False            go (Union [x])    k s      = go x k s            go (Union (x:xs)) k s      = go x k s || go (Union xs) k s@@ -118,6 +125,27 @@            -- smaller to avoid infinite recursion!            smaller orig k inp = P.length inp < orig && k inp +-- | Match everything, universal acceptor.+--+-- >>> prove $ \(s :: SString) -> s `match` everything+-- Q.E.D.+everything :: RegExp+everything = All++-- | Match nothing, universal rejector.+--+-- >>> prove $ \(s :: SString) -> sNot (s `match` nothing)+-- Q.E.D.+nothing :: RegExp+nothing = None++-- | Match any character, i.e., strings of length 1+--+-- >>> prove $ \(s :: SString) -> s `match` anyChar .<=> length s .== 1+-- Q.E.D.+anyChar :: RegExp+anyChar = AllChar+ -- | A literal regular-expression, matching the given string exactly. Note that -- with @OverloadedStrings@ extension, you can simply use a Haskell -- string to mean the same thing, so this function is rarely needed.@@ -213,6 +241,8 @@ -- (re.range "0" "9") -- >>> prove $ \c -> c `match` digit .<=> let v = digitToInt c in 0 .<= v .&& v .< 10 -- Q.E.D.+-- >>> prove $ \c -> sNot ((c::SChar) `match` (digit - digit))+-- Q.E.D. digit :: RegExp digit = Range '0' '9' @@ -323,6 +353,10 @@ Q.E.D. >>> prove $ \s -> s `match` Loop 2 5 "xyz" .=> length s .<= 15 Q.E.D.+>>> prove $ \s -> s `match` Power 3 "xyz" .=> length s .== 9+Q.E.D.+>>> prove $ \s -> s `match`  (exactly "xyz" ^ 3) .=> length s .== 9+Q.E.D. >>> prove $ \s -> match s (Loop 2 5 "xyz") .=> length s .>= 7 Falsifiable. Counter-example:   s0 = "xyzxyz" :: String@@ -331,5 +365,23 @@ >>> prove $ \s -> sNot $ (s::SString) `match` ("so close" * 0) Q.E.D. >>> prove $ \c -> (c :: SChar) `match` oneOf "abcd" .=> ord c .>= ord (literal 'a') .&& ord c .<= ord (literal 'd')+Q.E.D.+-}+++{- $regexpeq+/A note on Equality/ Regular expressions can be symbolically compared for equality. Note that the regular Haskell 'Eq'+instance and the symbolic version differ in semantics: 'Eq' instance checks for "structural" equality, i.e., that the two regular expressions+are constructed in precisely the same way. The symbolic equality, however, checks for language equality, i.e., that+the regular expressions correspond to the same set of strings. This is a bit unfortunate, but hopefully should not+cause much trouble in practice. Note that the only reason we support symbolic equality is to take advantage of+the internal decision procedures z3 provides for this case: A similar goal can be achieved by showing there is+no string accepted by one but not the other. However, this encoding doesn't perform well in z3.++>>> prove $ ("a" * KStar ("b" * "a")) .== (KStar ("a" * "b") * "a")+Q.E.D.+>>> prove $ ("a" * KStar ("b" * "a")) .== (KStar ("a" * "b") * "c")+Falsifiable+>>> prove $ ("a" * KStar ("b" * "a")) ./= (KStar ("a" * "b") * "c") Q.E.D. -}
Data/SBV/SMT/SMTLib2.hs view
@@ -48,7 +48,8 @@         hasFP          =  not (null [() | KFP{} <- Set.toList kindInfo])                        || KFloat     `Set.member` kindInfo                        || KDouble    `Set.member` kindInfo-        hasString      = KString    `Set.member` kindInfo+        hasString      = KString     `Set.member` kindInfo+        hasRegExp      = (not . null) [() | (_ :: RegExOp) <- G.universeBi asgnsSeq]         hasChar        = KChar      `Set.member` kindInfo         hasRounding    = not $ null [s | (s, _) <- usorts, s == "RoundingMode"]         hasBVs         = not (null [() | KBounded{} <- Set.toList kindInfo])@@ -124,6 +125,7 @@            | hasList               = setAll "has lists"            | hasChar               = setAll "has chars"            | hasString             = setAll "has strings"+           | hasRegExp             = setAll "has regular expressions"            | hasArrayInits         = setAll "has array initializers"            | hasOverflows          = setAll "has overflow checks" @@ -197,10 +199,12 @@              ++ concat arrayConstants              ++ [ "; --- uninterpreted constants ---" ]              ++ concatMap declUI uis+             ++ [ "; --- SBV Function definitions" | not (null funcMap) ]+             ++ concat [ declSBVFunc op nm | (op, nm) <- M.toAscList funcMap ]              ++ [ "; --- user given axioms ---" ]              ++ map declAx axs              ++ [ "; --- preQuantifier assignments ---" ]-             ++ concatMap (declDef cfg skolemMap tableMap) preQuantifierAssigns+             ++ concatMap (declDef cfg skolemMap tableMap funcMap) preQuantifierAssigns              ++ [ "; --- arrayDelayeds ---" ]              ++ concat arrayDelayeds              ++ [ "; --- arraySetups ---" ]@@ -320,20 +324,47 @@         tableMap  = IM.fromList $ map mkConstTable constTables ++ map mkSkTable skolemTables           where mkConstTable (((t, _, _), _), _) = (t, "table" ++ show t)                 mkSkTable    (((t, _, _), _), _) = (t, "table" ++ show t ++ forallArgs)++        -- SBV only functions.+        funcMap = M.fromList reverses+          where reverses = zip (nub [op | op@(SeqOp SBVReverse{}) <- G.universeBi asgnsSeq])+                               ["sbv.reverse_" ++ show i | i <- [(0::Int)..]]+         asgns = F.toList asgnsSeq          mkAssign a-          | null foralls = declDef cfg skolemMap tableMap a+          | null foralls = declDef cfg skolemMap tableMap funcMap a           | True         = [letShift (mkLet a)] -        mkLet (s, SBVApp (Label m) [e]) = "(let ((" ++ show s ++ " " ++ cvtSV                skolemMap          e ++ ")) ; " ++ m-        mkLet (s, e)                    = "(let ((" ++ show s ++ " " ++ cvtExp solverCaps rm skolemMap tableMap e ++ "))"+        mkLet (s, SBVApp (Label m) [e]) = "(let ((" ++ show s ++ " " ++ cvtSV                skolemMap                  e ++ ")) ; " ++ m+        mkLet (s, e)                    = "(let ((" ++ show s ++ " " ++ cvtExp solverCaps rm skolemMap tableMap funcMap e ++ "))"          userNameMap = M.fromList $ map ((\nSymVar -> (getSV nSymVar, getUserName' nSymVar)) . snd) inputs         userName s = case M.lookup s userNameMap of                         Just u  | show s /= u -> Just $ "tracks user variable " ++ show u                         _ -> Nothing +-- Declare "known" SBV functions here+declSBVFunc :: Op -> String -> [String]+declSBVFunc op nm = case op of+                      SeqOp (SBVReverse KString)   -> mkStringRev+                      SeqOp (SBVReverse (KList k)) -> mkSeqRev (KList k)+                      _                            -> error $ "Data.SBV.declSBVFunc: Unexpected internal function: " ++ show (op, nm)+  where mkStringRev = [ "(define-fun-rec " ++ nm ++ " ((str String)) String"+                      , "                (ite (= str \"\")"+                      , "                     \"\""+                      , "                     (str.++ (" ++ nm ++ " (str.substr str 1 (- (str.len str) 1)))"+                      , "                             (str.substr str 0 1))))"+                      ]+++        mkSeqRev k = [ "(define-fun-rec " ++ nm ++ " ((lst " ++ t ++ ")) " ++ t+                     , "                (ite (= lst (as seq.empty " ++ t ++ "))"+                     , "                     (as seq.empty " ++ t ++ ")"+                     , "                     (seq.++ (" ++ nm ++ " (seq.extract lst 1 (- (seq.len lst) 1))) (seq.unit (seq.nth lst 0)))))"+                     ]+          where t = smtType k+ -- | Declare new sorts declSort :: (String, Maybe [String]) -> [String] declSort (s, _)@@ -485,7 +516,7 @@             -- table declarations             ++ tableDecls             -- expressions-            ++ concatMap (declDef cfg skolemMap tableMap) (F.toList asgnsSeq)+            ++ concatMap (declDef cfg skolemMap tableMap funcMap) (F.toList asgnsSeq)             -- delayed equalities             ++ concat arrayDelayeds             -- table setups@@ -498,6 +529,10 @@         -- not support queries in the context of skolemized variables         skolemMap = M.empty +        -- The following is not really kosher; if it happens that a "new" variant of a function is used only incrementally.+        -- But we'll punt on this for now, as it should be rare and can be "worked-around" if necessary.+        funcMap = M.empty+         rm = roundingMode cfg          newKinds = Set.toList newKs@@ -520,11 +555,11 @@           = []           where solverCaps = capabilities (solver cfg) -declDef :: SMTConfig -> SkolemMap -> TableMap -> (SV, SBVExpr) -> [String]-declDef cfg skolemMap tableMap (s, expr) =+declDef :: SMTConfig -> SkolemMap -> TableMap -> FunctionMap -> (SV, SBVExpr) -> [String]+declDef cfg skolemMap tableMap funcMap (s, expr) =         case expr of-          SBVApp  (Label m) [e] -> defineFun cfg (s, cvtSV          skolemMap          e) (Just m)-          e                     -> defineFun cfg (s, cvtExp caps rm skolemMap tableMap e) Nothing+          SBVApp  (Label m) [e] -> defineFun cfg (s, cvtSV          skolemMap                  e) (Just m)+          e                     -> defineFun cfg (s, cvtExp caps rm skolemMap tableMap funcMap e) Nothing   where caps = capabilities (solver cfg)         rm   = roundingMode cfg @@ -552,8 +587,10 @@ declUI (i, t) = declareName i t Nothing  -- NB. We perform no check to as to whether the axiom is meaningful in any way.-declAx :: (String, [String]) -> String-declAx (nm, ls) = (";; -- user given axiom: " ++ nm ++ "\n") ++ intercalate "\n" ls+declAx :: (Bool, String, [String]) -> String+declAx (hasDefinition, nm, ls) = (";; -- user given " ++ what ++ ": " ++ nm ++ "\n") ++ intercalate "\n" ls+  where what | hasDefinition = "definition"+             | True          = "axiom"  constTable :: (((Int, Kind, Kind), [SV]), [String]) -> (String, [String]) constTable (((i, ak, rk), _elts), is) = (decl, zipWith wrap [(0::Int)..] is ++ setup)@@ -673,8 +710,9 @@ cvtType (SBVType xs) = "(" ++ unwords (map smtType body) ++ ") " ++ smtType ret   where (body, ret) = (init xs, last xs) -type SkolemMap = M.Map SV [SV]-type TableMap  = IM.IntMap String+type SkolemMap   = M.Map SV [SV]+type TableMap    = IM.IntMap String+type FunctionMap = M.Map Op String  -- Present an SV; inline true/false as needed cvtSV :: SkolemMap -> SV -> String@@ -696,8 +734,8 @@   | Just tn <- i `IM.lookup` m = tn   | True                       = "table" ++ show i  -- constant tables are always named this way -cvtExp :: SolverCapabilities -> RoundingMode -> SkolemMap -> TableMap -> SBVExpr -> String-cvtExp caps rm skolemMap tableMap expr@(SBVApp _ arguments) = sh expr+cvtExp :: SolverCapabilities -> RoundingMode -> SkolemMap -> TableMap -> FunctionMap -> SBVExpr -> String+cvtExp caps rm skolemMap tableMap functionMap expr@(SBVApp _ arguments) = sh expr   where ssv = cvtSV skolemMap          hasPB       = supportsPseudoBooleans caps@@ -788,16 +826,16 @@         stringOrChar _       = False         stringCmp swap o [a, b]           | stringOrChar (kindOf (head arguments))-          = let [a1, a2] | swap = [b, a]-                         | True = [a, b]+          = let (a1, a2) | swap = (b, a)+                         | True = (a, b)             in "(" ++ o ++ " " ++ a1 ++ " " ++ a2 ++ ")"         stringCmp _ o sbvs = error $ "SBV.SMT.SMTLib2.sh.stringCmp: Unexpected arguments: " ++ show (o, sbvs)          -- NB. Likewise for sequences         seqCmp swap o [a, b]           | KList{} <- kindOf (head arguments)-          = let [a1, a2] | swap = [b, a]-                         | True = [a, b]+          = let (a1, a2) | swap = (b, a)+                         | True = (a, b)             in "(" ++ o ++ " " ++ a1 ++ " " ++ a2 ++ ")"         seqCmp _ o sbvs = error $ "SBV.SMT.SMTLib2.sh.seqCmp: Unexpected arguments: " ++ show (o, sbvs) @@ -901,6 +939,14 @@            | bvOp  = shft ssv "bvlshr" "bvashr" a i            | True  = bad +        sh (SBVApp (ZeroExtend i) [a])+          | bvOp = "((_ zero_extend " ++ show i ++ ") " ++ ssv a ++ ")"+          | True = bad++        sh (SBVApp (SignExtend i) [a])+          | bvOp = "((_ sign_extend " ++ show i ++ ") " ++ ssv a ++ ")"+          | True = bad+         sh (SBVApp op args)           | Just f <- lookup op smtBVOpTable, ensureBVOrBool           = f (any hasSign args) (map ssv args)@@ -934,6 +980,15 @@         -- StrUnit is no-op, since a character in SMTLib is the same as a string         sh (SBVApp (StrOp StrUnit)     [a])  = ssv a         sh (SBVApp (StrOp op)          args) = "(" ++ show op ++ " " ++ unwords (map ssv args) ++ ")"++        sh (SBVApp (RegExOp o@RegExEq{})  []) = show o+        sh (SBVApp (RegExOp o@RegExNEq{}) []) = show o++        -- Reverse is special, since we need to generate call to the internally generated function+        sh inp@(SBVApp op@(SeqOp SBVReverse{}) args) = "(" ++ ops ++ " " ++ unwords (map ssv args) ++ ")"+          where ops = case op `M.lookup` functionMap of+                        Just s  -> s+                        Nothing -> error $ "SBV.SMT.SMTLib2.cvtExp.sh: impossible happened; can't translate: " ++ show inp          sh (SBVApp (SeqOp op) args) = "(" ++ show op ++ " " ++ unwords (map ssv args) ++ ")"
Data/SBV/SMT/Utils.hs view
@@ -51,7 +51,7 @@                        -> [((Int, Kind, Kind), [SV])]                   -- ^ auto-generated tables                        -> [(Int, ArrayInfo)]                            -- ^ user specified arrays                        -> [(String, SBVType)]                           -- ^ uninterpreted functions/constants-                       -> [(String, [String])]                          -- ^ user given axioms+                       -> [(Bool, String, [String])]                    -- ^ user given axioms/definitions                        -> SBVPgm                                        -- ^ assignments                        -> S.Seq (Bool, [(String, String)], SV)          -- ^ extra constraints                        -> SV                                            -- ^ output variable
Data/SBV/Set.hs view
@@ -60,11 +60,10 @@  import qualified Data.Generics.Uniplate.Data as G --- For doctest use only--- -- $setup--- >>> import Data.SBV.Core.Model--- >>> import Data.SBV.Provers.Prover+-- >>> -- For doctest purposes only:+-- >>> import Prelude hiding(null)+-- >>> import Data.SBV hiding(complement) -- >>> :set -XScopedTypeVariables  -- | Empty set.@@ -312,7 +311,10 @@ isUniversal = isFull  -- | Does the set have the given size? It implicitly asserts that the set--- it is operating on is finite. Also see 'Data.SBV.Set.card'.+-- it is operating on is finite. NB. Only z3 supported this call, and as+-- discussed in http://github.com/Z3Prover/z3/issues/3854, recent versions+-- of z3 doesn't support size calls either. So, you can only use this if you have+-- a sufficiently old version of z3. -- -- >>> prove $ \i -> hasSize (empty :: SSet Integer) i .== (i .== 0) -- Q.E.D.@@ -320,14 +322,16 @@ -- >>> sat $ \i -> hasSize (full :: SSet Integer) i -- Unsatisfiable ----- ->>> prove $ \a b i j k -> hasSize (a :: SSet Integer) i .&& hasSize (b :: SSet Integer) j .&& hasSize (a `union` b) k .=> k .>= i `smax` j--- Q.E.D.+-- The following tests are commented out since z3 no longer supports size: ----- ->>> prove $ \a b i j k -> hasSize (a :: SSet Integer) i .&& hasSize (b :: SSet Integer) j .&& hasSize (a `intersection` b) k .=> k .<= i `smin` j--- Q.E.D.+-- > >>> prove $ \a b i j k -> hasSize (a :: SSet Integer) i .&& hasSize (b :: SSet Integer) j .&& hasSize (a `union` b) k .=> k .>= i `smax` j+-- > Q.E.D. ----- ->>> prove $ \a k -> hasSize (a :: SSet Integer) k .=> k .>= 0--- Q.E.D.+-- > >>> prove $ \a b i j k -> hasSize (a :: SSet Integer) i .&& hasSize (b :: SSet Integer) j .&& hasSize (a `intersection` b) k .=> k .<= i `smin` j+-- > Q.E.D.+--+-- > >>> prove $ \a k -> hasSize (a :: SSet Integer) k .=> k .>= 0+-- > Q.E.D. hasSize :: (Ord a, SymVal a) => SSet a -> SInteger -> SBool hasSize sa si   -- Case 1: Constant regular set, see if the size matches@@ -546,9 +550,9 @@ False >>> sat $ \(x::SSet (Maybe Integer)) y z -> distinct [x, y, z] Satisfiable. Model:-  s0 = U - {Just 2} :: {Maybe Integer}-  s1 =           {} :: {Maybe Integer}-  s2 =            U :: {Maybe Integer}+  s0 =            U :: {Maybe Integer}+  s1 = U - {Just 3} :: {Maybe Integer}+  s2 =           {} :: {Maybe Integer}  However, if we compare two sets that are constructed as regular or in the complement form, we have to use a proof to establish equality:
Data/SBV/String.hs view
@@ -26,19 +26,22 @@         -- * Length, emptiness           length, null         -- * Deconstructing/Reconstructing-        , head, tail, uncons, init, singleton, strToStrAt, strToCharAt, (.!!), implode, concat, (.:), snoc, nil, (.++)+        , head, tail, uncons, init, singleton, strToStrAt, strToCharAt, (!!), implode, concat, (.:), snoc, nil, (++)         -- * Containment         , isInfixOf, isSuffixOf, isPrefixOf         -- * Substrings         , take, drop, subStr, replace, indexOf, offsetIndexOf+        -- * Reverse+        , reverse         -- * Conversion to\/from naturals         , strToNat, natToStr         ) where -import Prelude hiding (head, tail, init, length, take, drop, concat, null)+import Prelude hiding (head, tail, init, length, take, drop, concat, null, reverse, (++), (!!)) import qualified Prelude as P  import Data.SBV.Core.Data hiding (SeqOp(..))+import Data.SBV.Core.Data (SeqOp(SBVReverse)) import Data.SBV.Core.Model  import qualified Data.Char as C@@ -47,20 +50,20 @@  import Data.Proxy --- For doctest use only--- -- $setup--- >>> import Data.SBV.Provers.Prover (prove, sat)+-- >>> -- For doctest purposes only:+-- >>> import Data.SBV+-- >>> import Prelude hiding (head, tail, init, length, take, drop, concat, null, reverse, (++), (!!)) -- >>> :set -XOverloadedStrings  -- | Length of a string. -- -- >>> sat $ \s -> length s .== 2 -- Satisfiable. Model:---   s0 = "AB" :: String+--   s0 = "BA" :: String -- >>> sat $ \s -> length s .< 0 -- Unsatisfiable--- >>> prove $ \s1 s2 -> length s1 + length s2 .== length (s1 .++ s2)+-- >>> prove $ \s1 s2 -> length s1 + length s2 .== length (s1 ++ s2) -- Q.E.D. length :: SString -> SInteger length = lift1 StrLen (Just (fromIntegral . P.length))@@ -87,11 +90,11 @@  -- | @`tail`@ returns the tail of a string. Unspecified if the string is empty. ----- >>> prove $ \h s -> tail (singleton h .++ s) .== s+-- >>> prove $ \h s -> tail (singleton h ++ s) .== s -- Q.E.D. -- >>> prove $ \s -> length s .> 0 .=> length (tail s) .== length s - 1 -- Q.E.D.--- >>> prove $ \s -> sNot (null s) .=> singleton (head s) .++ tail s .== s+-- >>> prove $ \s -> sNot (null s) .=> singleton (head s) ++ tail s .== s -- Q.E.D. tail :: SString -> SString tail s@@ -106,7 +109,7 @@  -- | @`init`@ returns all but the last element of the list. Unspecified if the string is empty. ----- >>> prove $ \c t -> init (t .++ singleton c) .== t+-- >>> prove $ \c t -> init (t ++ singleton c) .== t -- Q.E.D. init :: SString -> SString init s@@ -129,7 +132,7 @@ -- | @`strToStrAt` s offset@. Substring of length 1 at @offset@ in @s@. Unspecified if -- offset is out of bounds. ----- >>> prove $ \s1 s2 -> strToStrAt (s1 .++ s2) (length s1) .== strToStrAt s2 0+-- >>> prove $ \s1 s2 -> strToStrAt (s1 ++ s2) (length s1) .== strToStrAt s2 0 -- Q.E.D. -- >>> sat $ \s -> length s .>= 2 .&& strToStrAt s 0 ./= strToStrAt s (length s - 1) -- Satisfiable. Model:@@ -153,8 +156,8 @@   = lift2 StrNth Nothing s i  -- | Short cut for 'strToCharAt'-(.!!) :: SString -> SInteger -> SChar-(.!!) = strToCharAt+(!!) :: SString -> SInteger -> SChar+(!!) = strToCharAt  -- | @`implode` cs@ is the string of length @|cs|@ containing precisely those -- characters. Note that there is no corresponding function @explode@, since@@ -165,16 +168,16 @@ -- >>> prove $ \c1 c2 c3 -> map (strToCharAt (implode [c1, c2, c3])) (map literal [0 .. 2]) .== [c1, c2, c3] -- Q.E.D. implode :: [SChar] -> SString-implode = foldr ((.++) . singleton) ""+implode = foldr ((++) . singleton) ""  -- | Prepend an element, the traditional @cons@. infixr 5 .: (.:) :: SChar -> SString -> SString-c .: cs = singleton c .++ cs+c .: cs = singleton c ++ cs  -- | Append an element snoc :: SString -> SChar -> SString-s `snoc` c = s .++ singleton c+s `snoc` c = s ++ singleton c  -- | Empty string. This value has the property that it's the only string with length 0: --@@ -183,26 +186,26 @@ nil :: SString nil = "" --- | Concatenate two strings. See also `.++`.+-- | Concatenate two strings. See also `++`. concat :: SString -> SString -> SString concat x y | isConcretelyEmpty x = y            | isConcretelyEmpty y = x-           | True                = lift2 StrConcat (Just (++)) x y+           | True                = lift2 StrConcat (Just (P.++)) x y  -- | Short cut for `concat`. ----- >>> sat $ \x y z -> length x .== 5 .&& length y .== 1 .&& x .++ y .++ z .== "Hello world!"+-- >>> sat $ \x y z -> length x .== 5 .&& length y .== 1 .&& x ++ y ++ z .== "Hello world!" -- Satisfiable. Model: --   s0 =  "Hello" :: String --   s1 =      " " :: String --   s2 = "world!" :: String-infixr 5 .++-(.++) :: SString -> SString -> SString-(.++) = concat+infixr 5 +++(++) :: SString -> SString -> SString+(++) = concat  -- | @`isInfixOf` sub s@. Does @s@ contain the substring @sub@? ----- >>> prove $ \s1 s2 s3 -> s2 `isInfixOf` (s1 .++ s2 .++ s3)+-- >>> prove $ \s1 s2 s3 -> s2 `isInfixOf` (s1 ++ s2 ++ s3) -- Q.E.D. -- >>> prove $ \s1 s2 -> s1 `isInfixOf` s2 .&& s2 `isInfixOf` s1 .<=> s1 .== s2 -- Q.E.D.@@ -215,7 +218,7 @@  -- | @`isPrefixOf` pre s@. Is @pre@ a prefix of @s@? ----- >>> prove $ \s1 s2 -> s1 `isPrefixOf` (s1 .++ s2)+-- >>> prove $ \s1 s2 -> s1 `isPrefixOf` (s1 ++ s2) -- Q.E.D. -- >>> prove $ \s1 s2 -> s1 `isPrefixOf` s2 .=> subStr s2 0 (length s1) .== s1 -- Q.E.D.@@ -228,7 +231,7 @@  -- | @`isSuffixOf` suf s@. Is @suf@ a suffix of @s@? ----- >>> prove $ \s1 s2 -> s2 `isSuffixOf` (s1 .++ s2)+-- >>> prove $ \s1 s2 -> s2 `isSuffixOf` (s1 ++ s2) -- Q.E.D. -- >>> prove $ \s1 s2 -> s1 `isSuffixOf` s2 .=> subStr s2 (length s2 - length s1) (length s1) .== s1 -- Q.E.D.@@ -252,7 +255,7 @@ -- -- >>> prove $ \s i -> length (drop i s) .<= length s -- Q.E.D.--- >>> prove $ \s i -> take i s .++ drop i s .== s+-- >>> prove $ \s i -> take i s ++ drop i s .== s -- Q.E.D. drop :: SInteger -> SString -> SString drop i s = ite (i .>= ls) (literal "")@@ -264,7 +267,7 @@ -- This function is under-specified when the offset is outside the range of positions in @s@ or @len@ -- is negative or @offset+len@ exceeds the length of @s@. ----- >>> prove $ \s i -> i .>= 0 .&& i .< length s .=> subStr s 0 i .++ subStr s i (length s - i) .== s+-- >>> prove $ \s i -> i .>= 0 .&& i .< length s .=> subStr s 0 i ++ subStr s i (length s - i) .== s -- Q.E.D. -- >>> sat  $ \i j -> subStr "hello" i j .== "ell" -- Satisfiable. Model:@@ -295,7 +298,7 @@ replace :: SString -> SString -> SString -> SString replace s src dst   | Just b <- unliteral src, P.null b   -- If src is null, simply prepend-  = dst .++ s+  = dst ++ s   | Just a <- unliteral s   , Just b <- unliteral src   , Just c <- unliteral dst@@ -305,7 +308,7 @@   where walk haystack needle newNeedle = go haystack   -- note that needle is guaranteed non-empty here.            where go []       = []                  go i@(c:cs)-                  | needle `L.isPrefixOf` i = newNeedle ++ genericDrop (genericLength needle :: Integer) i+                  | needle `L.isPrefixOf` i = newNeedle P.++ genericDrop (genericLength needle :: Integer) i                   | True                    = c : go cs  -- | @`indexOf` s sub@. Retrieves first position of @sub@ in @s@, @-1@ if there are no occurrences.@@ -340,6 +343,21 @@   | True   = lift3 StrIndexOf Nothing s sub offset +-- | @`reverse` s@ reverses the string.+-- >>> sat $ \s -> reverse s .== "abc"+-- Satisfiable. Model:+--   s0 = "cba" :: String+-- >>> prove $ \s -> reverse s .== "" .<=> null s+-- Q.E.D.+reverse :: SString -> SString+reverse s+  | Just s' <- unliteral s+  = literal (P.reverse s')+  | True+  = SBV $ SVal KString $ Right $ cache r+  where r st = do sva <- sbvToSV st s+                  newExpr st KString (SBVApp (SeqOp (SBVReverse KString)) [sva])+ -- | @`strToNat` s@. Retrieve integer encoded by string @s@ (ground rewriting only). -- Note that by definition this function only works when @s@ only contains digits, -- that is, if it encodes a natural number. Otherwise, it returns '-1'.@@ -420,3 +438,5 @@ isConcretelyEmpty :: SString -> Bool isConcretelyEmpty ss | Just s <- unliteral ss = P.null s                      | True                   = False++{-# ANN implode ("HLint: ignore Use concatMap" :: String) #-}
Data/SBV/Tools/BoundedFix.hs view
@@ -19,8 +19,9 @@  import Data.SBV --- Doctest only: -- $setup+-- >>> import Data.SBV+-- >>> -- For doctest purposes only: -- >>> bfac = bfix 10 "fac" fact where fact f n = ite (n .== 0) 1 ((n :: SInteger) * f (n-1))  -- | Bounded fixed-point operation. The call @bfix bnd nm f@ unrolls the recursion in @f@ at most
Data/SBV/Tools/BoundedList.hs view
@@ -32,8 +32,10 @@    )    where +import Prelude hiding ((++))+ import Data.SBV-import Data.SBV.List ((.:), (.++))+import Data.SBV.List ((.:), (++)) import qualified Data.SBV.List as L  -- | Case analysis on a symbolic list. (Not exported.)@@ -127,7 +129,7 @@  -- | Bounded reverse breverse :: SymVal a => Int -> SList a -> SList a-breverse cnt = bfoldr cnt (\a b -> b .++ L.singleton a) []+breverse cnt = bfoldr cnt (\a b -> b ++ L.singleton a) []  -- | Bounded paramorphism (not exported). bpara :: (SymVal a, SymVal b) => Int -> (SBV a -> SBV [a] -> SBV b -> SBV b) -> SBV b -> SList a -> SBV b
Data/SBV/Tools/GenTest.hs view
@@ -9,7 +9,7 @@ -- Test generation from symbolic programs ----------------------------------------------------------------------------- -{-# OPTIONS_GHC -Wall -Werror #-}+{-# OPTIONS_GHC -Wall -Werror -Wno-incomplete-uni-patterns #-}  module Data.SBV.Tools.GenTest (         -- * Test case generation
Data/SBV/Tools/Induction.hs view
@@ -139,7 +139,7 @@                                                   return $ Just ex          strengthen []             cont = cont-        strengthen ((nm, st):sts) cont = try ("Proving strengthening initation  : " ++ nm)+        strengthen ((nm, st):sts) cont = try ("Proving strengthening initiation  : " ++ nm)                                              (\s -> initial s .=> st s)                                              (Failed (Initiation (Just nm)))                                              $ try ("Proving strengthening consecution: " ++ nm)
Data/SBV/Tools/Overflow.hs view
@@ -45,9 +45,9 @@ import Data.Word import Data.Proxy --- Doctest only -- $setup--- >>> import Data.SBV.Provers.Prover (prove, allSat)+-- >>> -- For doctest purposes only:+-- >>> import Data.SBV  -- | Detecting underflow/overflow conditions. For each function, -- the first result is the condition under which the computation
Data/SBV/Tools/Range.hs view
@@ -29,8 +29,9 @@  import Data.SBV.Internals hiding (Range, free_) --- Doctest only -- $setup+-- >>> -- For doctest purposes only:+-- >>> import Data.SBV -- >>> :set -XScopedTypeVariables  -- | A boundary value
Data/SBV/Tuple.hs view
@@ -34,12 +34,10 @@ import Data.SBV.Core.Symbolic import Data.SBV.Core.Model --- For doctest use only--- -- $setup+-- >>> -- For doctest purposes only: -- >>> :set -XTypeApplications--- >>> import Data.SBV.Provers.Prover (prove)--- >>> import Data.SBV.Core.Model+-- >>> import Data.SBV  -- | Field access, inspired by the lens library. This is merely reverse -- application, but allows us to write things like @(1, 2)^._1@ which is
Data/SBV/Utils/CrackNum.hs view
@@ -11,7 +11,7 @@  {-# LANGUAGE NamedFieldPuns #-} -{-# OPTIONS_GHC -Wall -Werror #-}+{-# OPTIONS_GHC -Wall -Werror -Wno-incomplete-uni-patterns #-}  module Data.SBV.Utils.CrackNum (         crackNum@@ -34,6 +34,7 @@  -- | A class for cracking things deeper, if we know how. class CrackNum a where+  -- | Convert an item to possibly bit-level description, if possible.   crackNum :: a -> Maybe String  -- | CVs are easy to crack
Data/SBV/Utils/PrettyNum.hs view
@@ -12,7 +12,7 @@ {-# LANGUAGE FlexibleInstances   #-} {-# LANGUAGE ScopedTypeVariables #-} -{-# OPTIONS_GHC -Wall -Werror #-}+{-# OPTIONS_GHC -Wall -Werror -Wno-incomplete-uni-patterns #-}  module Data.SBV.Utils.PrettyNum (         PrettyNum(..), readBin, shex, chex, shexI, sbin, sbinI
Data/SBV/Utils/SExpr.hs view
@@ -366,10 +366,12 @@ parseLambdaExpression funExpr = case funExpr of                                   EApp [ECon "lambda", EApp params, body] -> mapM getParam params >>= flip lambda body >>= chainAssigns                                   _                                       -> Nothing-  where getParam (EApp [ECon v, _]) = Just v-        getParam _                  = Nothing+  where getParam (EApp [ECon v, ECon ty]) = Just (v, ty == "Bool")+        getParam (EApp [ECon v, _      ]) = Just (v, False)+        getParam _                        = Nothing -        lambda :: [String] -> SExpr -> Maybe [Either ([SExpr], SExpr) SExpr]+        lambda :: [(String, Bool)]  -- Bool is True if this is a boolean variable. Otherwise we don't keep track of the type+               -> SExpr -> Maybe [Either ([SExpr], SExpr) SExpr]         lambda params body = reverse <$> go [] body           where true  = ENum (1, Nothing)                 false = ENum (0, Nothing)@@ -422,23 +424,27 @@                 -- select takes the condition of an ite, and returns precisely what match is done to the parameters                 select :: SExpr -> Maybe [SExpr]                 select e-                   | Just dict <- build e [] = mapM (`lookup` dict) params+                   | Just dict <- build e [] = mapM (`lookup` dict) paramNames                    | True                    = Nothing-                  where -- build a dictionary of assignments from the scrutinee+                  where paramNames = map fst params++                        -- build a dictionary of assignments from the scrutinee                         build :: SExpr -> [(String, SExpr)] -> Maybe [(String, SExpr)]                         build (EApp (ECon "and" : rest)) sofar = let next _ Nothing  = Nothing                                                                      next c (Just x) = build c x                                                                  in foldr next (Just sofar) rest -                        build expr sofar | Just (v, r) <- grok expr, v `elem` params = Just $ (v, r) : sofar-                                         | True                                      = Nothing+                        build expr sofar | Just (v, r) <- grok expr, v `elem` paramNames = Just $ (v, r) : sofar+                                         | True                                          = Nothing                          -- See if we can figure out what z3 is telling us; hopefully this                         -- mapping covers everything we can see:                         grok (EApp [ECon "=", ECon v, r]) = Just (v, r)                         grok (EApp [ECon "=", r, ECon v]) = Just (v, r)                         grok (EApp [ECon "not", ECon v])  = Just (v, false) -- boolean negation, require it to be false-                        grok (ECon v)                     = Just (v, true)  -- boolean identity, require it to be true+                        grok (ECon v)                     = case v `lookup` params of+                                                               Just True -> Just (v, true)  -- boolean identity, require it to be true+                                                               _         -> Nothing                          -- Tough luck, we couldn't understand:                         grok _ = Nothing
Data/SBV/Utils/TDiff.hs view
@@ -46,7 +46,9 @@          picoFactor :: Integer          picoFactor = (10 :: Integer) ^ (12 :: Integer) -         [s2p, m2s, h2m, d2h] = drop 1 $ scanl (*) 1 [picoFactor, 60, 60, 24]+         (s2p, m2s, h2m, d2h) = case drop 1 $ scanl (*) 1 [picoFactor, 60, 60, 24] of+                                  (s2pv : m2sv : h2mv : d2hv : _) -> (s2pv, m2sv, h2mv, d2hv)+                                  _                               -> (0, 0, 0, 0)  -- won't ever happen           (days,    days')    = total    `divMod` d2h          (hours,   hours')   = days'    `divMod` h2m
Documentation/SBV/Examples/BitPrecise/BrokenSearch.hs view
@@ -17,11 +17,15 @@ import Data.SBV import Data.SBV.Tools.Overflow +-- $setup+-- >>> import Data.SBV+-- >>> import Data.Int+ -- | Model the mid-point computation of the binary search, which is broken due to arithmetic overflow. -- Note how we use the overflow checking variants of the arithmetic operators. We have: -- -- >>> checkArithOverflow midPointBroken--- Documentation/SBV/Examples/BitPrecise/BrokenSearch.hs:35:28:+!: SInt32 addition overflows: Violated. Model:+-- ./Documentation/SBV/Examples/BitPrecise/BrokenSearch.hs:39:32:+!: SInt32 addition overflows: Violated. Model: --   low  = 2147483647 :: Int32 --   high = 2147483647 :: Int32 --
Documentation/SBV/Examples/BitPrecise/MultMask.hs view
@@ -32,6 +32,7 @@ module Documentation.SBV.Examples.BitPrecise.MultMask where  import Data.SBV+import Data.SBV.Control  -- | Find the multiplier and the mask as described. We have: --@@ -46,10 +47,18 @@ -- -- NB. Depending on your z3 version, you might also get the following -- multiplier as the result: 0x8202040810204081. That value works just fine as well!+--+-- NB. Note the custom call to z3 with a specific tactic. A simple call to z3 unfortunately+-- does not terminate quickly. maskAndMult :: IO () maskAndMult = print =<< satWith z3{printBase=16} find-  where find = do mask <- exists "mask"-                  mult <- exists "mult"-                  inp  <- forall "inp"+  where find = do -- Magic incantation to make the test go fast. See <http://github.com/Z3Prover/z3/issues/5660> for details.+                  setOption $ OptionKeyword ":tactic.default_tactic" ["sat"]+                  setOption $ OptionKeyword ":sat.euf"               ["true"]+                  setOption $ OptionKeyword ":smt.ematching"         ["false"]++                  mask <- sbvExists "mask"+                  mult <- sbvExists "mult"+                  inp  <- sbvForall "inp"                   let res = (mask .&. inp) * (mult :: SWord64)                   solve [inp `sExtractBits` [7, 15 .. 63] .== res `sExtractBits` [56 .. 63]]
Documentation/SBV/Examples/BitPrecise/PrefixSum.hs view
@@ -21,6 +21,10 @@  import Data.SBV +-- $setup+-- >>> -- For doctest purposes only:+-- >>> import Data.SBV+ ---------------------------------------------------------------------- -- * Formalizing power-lists ----------------------------------------------------------------------
Documentation/SBV/Examples/CodeGeneration/GCD.hs view
@@ -20,6 +20,11 @@ import Data.SBV import Data.SBV.Tools.CodeGen +-- $setup+-- >>> -- For doctest purposes only:+-- >>> import Data.SBV+-- >>> import Data.SBV.Tools.CodeGen+ ----------------------------------------------------------------------------- -- * Computing GCD -----------------------------------------------------------------------------
Documentation/SBV/Examples/CodeGeneration/PopulationCount.hs view
@@ -17,6 +17,10 @@ import Data.SBV import Data.SBV.Tools.CodeGen +-- $setup+-- >>> -- For doctest purposes only:+-- >>> import Data.SBV+ ----------------------------------------------------------------------------- -- * Reference: Slow but /obviously/ correct -----------------------------------------------------------------------------
Documentation/SBV/Examples/CodeGeneration/Uninterpreted.hs view
@@ -22,6 +22,10 @@ import Data.SBV import Data.SBV.Tools.CodeGen +-- $setup+-- >>> -- For doctest purposes only:+-- >>> import Data.SBV+ -- | A definition of shiftLeft that can deal with variable length shifts. -- (Note that the ``shiftL`` method from the 'Bits' class requires an 'Int' shift -- amount.) Unfortunately, this'll generate rather clumsy C code due to the
Documentation/SBV/Examples/Crypto/AES.hs view
@@ -26,9 +26,8 @@  {-# LANGUAGE DataKinds        #-} {-# LANGUAGE ParallelListComp #-}-{-# LANGUAGE TypeApplications #-} -{-# OPTIONS_GHC -Wall -Werror #-}+{-# OPTIONS_GHC -Wall -Werror -Wno-incomplete-uni-patterns #-}  module Documentation.SBV.Examples.Crypto.AES where @@ -42,6 +41,10 @@ import Data.Maybe (fromJust)  import Numeric (showHex)++-- $setup+-- >>> -- For doctest purposes only:+-- >>> import Data.SBV  ----------------------------------------------------------------------------- -- * Formalizing GF(2^8)
Documentation/SBV/Examples/Crypto/SHA.hs view
@@ -21,6 +21,8 @@ {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TypeApplications    #-} +{-# OPTIONS_GHC -Wall -Werror -Wno-incomplete-uni-patterns #-}+ module Documentation.SBV.Examples.Crypto.SHA where  import Data.SBV@@ -177,8 +179,7 @@  -- | Prepare the message by turning it into blocks. We also check for the message -- size requirement here. Note that this won't actually happen in practice as the input--- length would be > 2^64 (or 2^128), and you'd run out of memory first! Such a check-+-- length would be > 2^64 (or 2^128), and you'd run out of memory first! prepareMessage :: forall w. (Num w, ByteConverter w) => SHA w -> String -> [Block w] prepareMessage SHA{wordSize, blockSize} s   | msgLen >= maxLen@@ -187,7 +188,7 @@   = parse $ chunkBy (wordSize `div` 8) fromBytes padded   where -- Maximum message size supported by the algorithm         maxLen :: Integer-        maxLen = 2^(2* fromIntegral wordSize :: Integer)+        maxLen = 2^(2 * fromIntegral wordSize :: Integer)          -- Size of the input in bits         msgLen :: Integer
Documentation/SBV/Examples/Existentials/CRCPolynomial.hs view
@@ -51,9 +51,9 @@ -- | Generate good CRC polynomials for 48-bit words, given the hamming distance @hd@. genPoly :: SWord8 -> Int -> IO () genPoly hd maxCnt = do res <- allSatWith defaultSMTCfg{allSatMaxModelCount = Just maxCnt} $ do-                                p <- exists "polynomial" -- the polynomial is existentially specified-                                s <- forall "sent"       -- sent word, universal-                                r <- forall "received"   -- received word, universal+                                p <- sbvExists "polynomial" -- the polynomial is existentially specified+                                s <- sbvForall "sent"       -- sent word, universal+                                r <- sbvForall "received"   -- received word, universal                                 -- assert that the polynomial @p@ is good. Note                                 -- that we also supply the extra information that                                 -- the least significant bit must be set in the
Documentation/SBV/Examples/Lists/BoundedMutex.hs view
@@ -24,7 +24,8 @@ import Data.SBV import Data.SBV.Control -import Data.SBV.List ((.!!))+import Prelude hiding ((!!))+import Data.SBV.List ((!!)) import qualified Data.SBV.List              as L import qualified Data.SBV.Tools.BoundedList as L @@ -142,7 +143,7 @@                         constrain $ validTurns    b turns p1 p2                          -- Ensure that the second process becomes ready in the second cycle:-                        constrain $ p2 .!! 1 .== sReady+                        constrain $ p2 !! 1 .== sReady                          -- Find a trace where p2 never goes critical                         -- counter example, we would've found a violation!
+ Documentation/SBV/Examples/Lists/CountOutAndTransfer.hs view
@@ -0,0 +1,65 @@+-----------------------------------------------------------------------------+-- |+-- Module    : Documentation.SBV.Examples.Lists.CountOutAndTransfer+-- Copyright : (c) Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Shows that COAT (Count-out-and-transfer) trick preserves order of cards.+-- From pg. 35 of <http://graphics8.nytimes.com/packages/pdf/crossword/Mulcahy_Mathematical_Card_Magic-Sample2.pdf>:+--+-- /Given a packet of n cards, COATing k cards refers to counting out that many from the top into a pile, thus reversing their order, and transferring those as a unit to the bottom./+--+-- We show that if you COAT 4 times where @k@ is at least @n/2@ for a deck of size @n@, then the deck remains in the same order.+-----------------------------------------------------------------------------++{-# LANGUAGE ScopedTypeVariables #-}++{-# OPTIONS_GHC -Wall -Werror #-}++module Documentation.SBV.Examples.Lists.CountOutAndTransfer where++import Prelude hiding (length, take, drop, reverse, (++))++import Data.SBV+import Data.SBV.List++-- | Count-out-and-transfer (COAT): Take @k@ cards from top, reverse it,+-- and put it at the bottom of a deck.+coat :: SymVal a => SInteger -> SList a -> SList a+coat k cards = drop k cards ++ reverse (take k cards)++-- | COAT 4 times.+fourCoat :: SymVal a => SInteger -> SList a -> SList a+fourCoat k = coat k . coat k . coat k . coat k++-- | A deck is simply a list of integers. Note that a regular deck will have+-- distinct cards, we do not impose this in our proof. That is, the+-- proof works regardless whether we put duplicates into the deck, which+-- generalizes the theorem.+type Deck = SList Integer++-- | Key property of COATing. If you take a deck of size @n@, and+-- COAT it 4 times, then the deck remains in the same order. The COAT+-- factor, @k@, must be greater than half the size of the deck size.+--+-- Note that the proof time increases significantly with @n@.+-- Here's a proof for deck size of 6, for all @k@ >= @3@.+--+-- >>> coatCheck 6+-- Q.E.D.+--+-- It's interesting to note that one can also express this theorem+-- by making @n@ symbolic as well. However, doing so definitely requires+-- an inductive proof, and the SMT-solver doesn't handle this case+-- out-of-the-box, running forever.+coatCheck :: Integer -> IO ThmResult+coatCheck n = prove $ do+     deck :: Deck <- free "deck"+     k            <- free "k"++     constrain $ length deck .== literal n+     constrain $ 2*k .>= literal n++     pure $ deck .== fourCoat k deck
Documentation/SBV/Examples/Lists/Fibonacci.hs view
@@ -15,7 +15,9 @@  import Data.SBV -import           Data.SBV.List ((.!!))+import Prelude hiding ((!!))++import           Data.SBV.List ((!!)) import qualified Data.SBV.List as L  import Data.SBV.Control@@ -36,11 +38,11 @@              constrain $ L.length fibs .== 200               -- Constrain first two elements-             constrain $ fibs .!! 0 .== 1-             constrain $ fibs .!! 1 .== 1+             constrain $ fibs !! 0 .== 1+             constrain $ fibs !! 1 .== 1               -- Constrain an arbitrary element at index `i`-             let constr i = constrain $ fibs .!! i + fibs .!! (i+1) .== fibs .!! (i+2)+             let constr i = constrain $ fibs !! i + fibs !! (i+1) .== fibs !! (i+2)               -- Constrain the remaining elts              mapM_ (constr . fromIntegral) [(0::Int) .. 197]
Documentation/SBV/Examples/Lists/Nested.hs view
@@ -19,7 +19,8 @@ import Data.SBV import Data.SBV.Control -import Data.SBV.List ((.!!))+import Prelude hiding ((!!))+import Data.SBV.List ((!!)) import qualified Data.SBV.List as L  -- | Simple example demonstrating the use of nested lists. We have:@@ -30,8 +31,8 @@ nestedExample :: IO () nestedExample = runSMT $ do a :: SList [Integer] <- free "a" -                            constrain $ a .!! 0 .== [1, 2, 3]-                            constrain $ a .!! 1 .== [4, 5, 6, 7]+                            constrain $ a !! 0 .== [1, 2, 3]+                            constrain $ a !! 1 .== [4, 5, 6, 7]                             constrain $ L.tail (L.tail a) .== [[8, 9, 10], [11, 12, 13]]                             constrain $ L.length a .== 4
Documentation/SBV/Examples/Misc/Auxiliary.hs view
@@ -15,7 +15,7 @@ -- considering them explicitly in model construction. ----------------------------------------------------------------------------- -{-# LANGUAGE OverloadedStrings   #-}+{-# LANGUAGE OverloadedStrings #-}  {-# OPTIONS_GHC -Wall -Werror #-}
+ Documentation/SBV/Examples/Misc/Definitions.hs view
@@ -0,0 +1,67 @@+-----------------------------------------------------------------------------+-- |+-- Module    : Documentation.SBV.Examples.Misc.Definitions+-- Copyright : (c) Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Demonstrates how we can add actual SMT-definitions for functions+-- that cannot otherwise be defined in SBV. Typically, these are used+-- for recursive definitions.+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror #-}++module Documentation.SBV.Examples.Misc.Definitions where++import Data.SBV++-- | Sum of numbers from 0 to the given number.+-- Note that this cannot be defined as a regular Haskell function, as+-- it wouldn't terminate as it recurses on a symbolic argument.+sumToN :: SInteger -> SInteger+sumToN = uninterpret "sumToN"++-- | Add the definition of sum to the SMT solver. Note that SBV+-- performs no checks on your definition, neither that it is+-- well formed, or even has the correct type!+defineSum :: Symbolic ()+defineSum = addSMTDefinition "sumToN"+                [ "(define-fun-rec sumToN ((x Int)) Int"+                , "                (ite (<= x 0)"+                , "                     0"+                , "                     (+ x (sumToN (- x 1)))))"+                ]++-- | A simple proof using 'sumToN'. We get a failure, because we haven't+-- given the solver the definition, and thus it goes completely uninterpreted.+--+-- We have:+--+-- >>> badExample+-- Falsifiable. Counter-example:+--   sumToN :: Integer -> Integer+--   sumToN _ = 0+--+-- Since 'sumToN' remains uninterpreted, the solver gave us a model that obviously+-- fails the property.+badExample :: IO ThmResult+badExample = prove $ do+        let check = sumToN 5 .== 15  -- Should fail, even though 5*6/2 = 15+        pure check :: Predicate++-- | Same example, except this time we give the solver the definition of the function,+-- and thus the proof goes through.+--+-- We have:+--+-- >>> goodExample+-- Q.E.D.+--+-- In this case, the solver has the definition, and proves the predicate as expected.+goodExample :: IO ThmResult+goodExample = prove $ do+        defineSum+        let check = sumToN 5 .== 15  -- Should fail, even though 5*6/2 = 15+        pure check :: Predicate
Documentation/SBV/Examples/Misc/Enumerate.hs view
@@ -64,8 +64,8 @@ -- Satisfiable. Model: --   maxE = C :: E maxE :: IO SatResult-maxE = sat $ do mx <- exists "maxE"-                e  <- forall "e"+maxE = sat $ do mx <- sbvExists "maxE"+                e  <- sbvForall "e"                 return $ mx .>= (e::SE)  -- | Similarly, we get the minimum element. We have:@@ -74,6 +74,6 @@ -- Satisfiable. Model: --   minE = A :: E minE :: IO SatResult-minE = sat $ do mx <- exists "minE"-                e  <- forall "e"+minE = sat $ do mx <- sbvExists "minE"+                e  <- sbvForall "e"                 return $ mx .<= (e::SE)
Documentation/SBV/Examples/Misc/Floating.hs view
@@ -26,6 +26,10 @@  import Data.SBV +-- $setup+-- >>> -- For doctest purposes only:+-- >>> import Data.SBV+ ----------------------------------------------------------------------------- -- * FP addition is not associative -----------------------------------------------------------------------------@@ -62,19 +66,19 @@ -- -- >>> assocPlusRegular -- Falsifiable. Counter-example:---   x = -1.860921e38 :: Float---   y = 2.1240016e32 :: Float---   z = 2.2772656e33 :: Float+--   x = -3.0359216e35 :: Float+--   y =   5.058223e30 :: Float+--   z =   8.307169e34 :: Float -- -- Indeed, we have: ----- >>> let x = -1.860921e38 :: Float--- >>> let y = 2.1240016e32 :: Float--- >>> let z = 2.2772656e33 :: Float+-- >>> let x = -3.0359216e35 :: Float+-- >>> let y =   5.058223e30 :: Float+-- >>> let z =   8.307169e34 :: Float -- >>> x + (y + z)--- -1.860896e38+-- -2.205154e35 -- >>> (x + y) + z--- -1.8608963e38+-- -2.2051543e35 -- -- Note the difference in the results! assocPlusRegular :: IO ThmResult@@ -96,13 +100,13 @@ -- -- >>> nonZeroAddition -- Falsifiable. Counter-example:---   a =  3.2446953e28 :: Float---   b = -4.486113e-39 :: Float+--   a = 2.5068128e37 :: Float+--   b =    -5.354632 :: Float -- -- Indeed, we have: ----- >>> let a =  3.2446953e28 :: Float--- >>> let b = -4.486113e-39 :: Float+-- >>> let a = 2.5068128e37 :: Float+-- >>> let b =    -5.354632 :: Float -- >>> a + b == a -- True -- >>> b == 0@@ -125,11 +129,11 @@ -- -- >>> multInverse -- Falsifiable. Counter-example:---   a = 2.944504e-39 :: Float+--   a = 1.2760589e38 :: Float -- -- Indeed, we have: ----- >>> let a = 2.944504e-39 :: Float+-- >>> let a = 1.2760589e38 :: Float -- >>> a * (1/a) -- 0.99999994 multInverse :: IO ThmResult@@ -151,28 +155,28 @@ -- -- >>> roundingAdd -- Satisfiable. Model:---   rm = RoundTowardPositive :: RoundingMode---   x  =       3.6969435e-35 :: Float---   y  =      -1.1628614e-38 :: Float+--   rm = RoundTowardNegative :: RoundingMode+--   x  =       3.2806003e-21 :: Float+--   y  =       -5.749071e-20 :: Float -- -- (Note that depending on your version of Z3, you might get a different result.) -- Unfortunately Haskell floats do not allow computation with arbitrary rounding modes, but SBV's -- 'SFloatingPoint' type does. We have: ----- >>> fpAdd sRoundNearestTiesToEven 3.6969435e-35 (-1.1628614e-38) :: SFPSingle--- 3.69578064e-35 :: SFloatingPoint 8 24--- >>> fpAdd sRoundTowardPositive    3.6969435e-35 (-1.1628614e-38) :: SFPSingle--- 3.69578093e-35 :: SFloatingPoint 8 24+-- >>> fpAdd sRoundNearestTiesToEven 3.2806003e-21 (-5.749071e-20) :: SFPSingle+-- -5.42101054e-20 :: SFloatingPoint 8 24+-- >>> fpAdd sRoundTowardNegative 3.2806003e-21 (-5.749071e-20) :: SFPSingle+-- -5.42101086e-20 :: SFloatingPoint 8 24 ----- We can see why these two results are indeed different: The 'RoundTowardPositive'--- (which rounds towards positive infinity from zero) produces a larger result. Indeed, if we treat these numbers+-- We can see why these two results are indeed different: The 'RoundTowardNegative'+-- (which rounds towards negative infinity from zero) produces a smaller result. Indeed, if we treat these numbers -- as 'Double' values, we get: ----- >>> 3.6969435e-35 + (-1.1628614e-38) :: Double--- 3.6957806386e-35+-- >>> 3.2806003e-21 + (-5.749071e-20) :: Double+-- -5.42101097e-20 ----- we see that the "more precise" result is larger than what the 'Float' value is, justifying the--- larger value with 'RoundTowardPositive'. A more detailed study is beyond our current scope, so we'll+-- we see that the "more precise" result is smaller than what the 'Float' value is, justifying the+-- smaller value with 'RoundTowardNegative'. A more detailed study is beyond our current scope, so we'll -- merely note that floating point representation and semantics is indeed a thorny -- subject, and point to <http://ece.uwaterloo.ca/~dwharder/NumericalAnalysis/02Numerics/Double/paper.pdf> as -- an excellent guide.
Documentation/SBV/Examples/Misc/NestedArray.hs view
@@ -23,7 +23,7 @@ -- another integer to integer array in each index. We have: -- -- >>> nestedArray--- (0,10)+-- (2,10) nestedArray :: IO (Integer, Integer) nestedArray = runSMT $ do   idx <- sInteger "idx"
Documentation/SBV/Examples/Misc/Newtypes.hs view
@@ -21,6 +21,10 @@ import Data.SBV import qualified Data.SBV.Internals as SI +-- $setup+-- >>> -- For doctest purposes only:+-- >>> import Data.SBV+ -- | A 'Metres' is a newtype wrapper around 'Integer'. newtype Metres = Metres Integer deriving (Real, Integral, Num, Enum, Eq, Ord) @@ -78,7 +82,7 @@ -- >>> sat problem -- Satisfiable. Model: --   floorToCeiling =   3 :: Integer---   humanheight    = 255 :: Word16+--   humanheight    = 253 :: Word16 problem :: Predicate problem = do     ceiling     :: SMetres          <- free "floorToCeiling"
Documentation/SBV/Examples/Misc/NoDiv0.hs view
@@ -30,7 +30,7 @@ -- this to be safe: -- -- >>> test1--- [Documentation/SBV/Examples/Misc/NoDiv0.hs:38:14:checkedDiv: Divisor should not be 0: Violated. Model:+-- [./Documentation/SBV/Examples/Misc/NoDiv0.hs:38:14:checkedDiv: Divisor should not be 0: Violated. Model: --   s0 = 0 :: Int32 --   s1 = 0 :: Int32] --@@ -40,7 +40,7 @@ -- | Repeat the test, except this time we explicitly protect against the bad case. We have: -- -- >>> test2--- [Documentation/SBV/Examples/Misc/NoDiv0.hs:46:41:checkedDiv: Divisor should not be 0: No violations detected]+-- [./Documentation/SBV/Examples/Misc/NoDiv0.hs:46:41:checkedDiv: Divisor should not be 0: No violations detected] -- test2 :: IO [SafeResult] test2 = safe $ \x y -> ite (y .== 0) 3 (checkedDiv x y)
Documentation/SBV/Examples/Misc/SetAlgebra.hs view
@@ -373,6 +373,6 @@ >>> prove $ \(a :: SI) b c -> (b `intersection` c) `isSubsetOf` a .=> b `isSubsetOf` a .&& c `isSubsetOf` a Falsifiable. Counter-example:   s0 = U - {2} :: {Integer}-  s1 =      {} :: {Integer}-  s2 =     {2} :: {Integer}+  s1 =     {2} :: {Integer}+  s2 =      {} :: {Integer} -}
Documentation/SBV/Examples/Misc/Tuple.hs view
@@ -24,7 +24,8 @@ import Data.SBV.Tuple import Data.SBV.Control -import Data.SBV.List   ((.!!))+import Prelude hiding ((!!))+import Data.SBV.List   ((!!)) import Data.SBV.RegExp  import qualified Data.SBV.String as S@@ -65,13 +66,13 @@                                             r = asciiLower * KStar (asciiLetter + digit + "_" + "'")                                       in l .== fromIntegral i+3 .&& s `match` r -                          restrict i = case untuple (dict .!! fromIntegral i) of+                          restrict i = case untuple (dict !! fromIntegral i) of                                          (k, v) -> constrain $ goodKey i k .&& v .== S.length k                        mapM_ restrict range                        -- require distinct keys:-                      let keys = [(dict .!! fromIntegral i)^._1 | i <- range]+                      let keys = [(dict !! fromIntegral i)^._1 | i <- range]                       constrain $ distinct keys                        query $ do ensureSat
Documentation/SBV/Examples/Optimization/ExtField.hs view
@@ -15,6 +15,10 @@  import Data.SBV +-- $setup+-- >>> -- For doctest purposes only:+-- >>> import Data.SBV+ -- | Optimization goals where min/max values might require assignments -- to values that are infinite (integer case), or infinite/epsilon (real case). -- This simple example demonstrates how SBV can be used to extract such values.
Documentation/SBV/Examples/Optimization/LinearOpt.hs view
@@ -15,6 +15,10 @@  import Data.SBV +-- $setup+-- >>> -- For doctest purposes only:+-- >>> import Data.SBV+ -- | Taken from <http://people.brunel.ac.uk/~mastjjb/jeb/or/morelp.html> -- --    *  maximize 5x1 + 6x2
Documentation/SBV/Examples/Optimization/Production.hs view
@@ -15,6 +15,10 @@  import Data.SBV +-- $setup+-- >>> -- For doctest purposes only:+-- >>> import Data.SBV+ -- | Taken from <http://people.brunel.ac.uk/~mastjjb/jeb/or/morelp.html> -- -- A company makes two products (X and Y) using two machines (A and B).
Documentation/SBV/Examples/Optimization/VM.hs view
@@ -15,7 +15,11 @@  import Data.SBV --- | The allocation problem. Inspired by: <http://rise4fun.com/Z3/tutorialcontent/optimization#h25>+-- $setup+-- >>> -- For doctest purposes only:+-- >>> import Data.SBV++-- | Computer allocation problem: -- --   - We have three virtual machines (VMs) which require 100, 50 and 15 GB hard disk respectively. --
Documentation/SBV/Examples/ProofTools/BMC.hs view
@@ -18,7 +18,6 @@ -- What if @y@ starts at @11@? ----------------------------------------------------------------------------- -{-# LANGUAGE DeriveFoldable        #-} {-# LANGUAGE DeriveTraversable     #-} {-# LANGUAGE FlexibleInstances     #-} {-# LANGUAGE MultiParamTypeClasses #-}@@ -83,7 +82,7 @@ -- BMC: Iteration: 2 -- BMC: Iteration: 3 -- BMC: Solution found at iteration 3--- Right (3,[(0,10),(0,6),(0,2),(2,2)])+-- Right (3,[(0,10),(0,6),(2,6),(2,2)]) -- -- As expected, there's a solution in this case. Furthermore, since the BMC engine -- found a solution at depth @3@, we also know that there is no solution at
Documentation/SBV/Examples/ProofTools/Fibonacci.hs view
@@ -23,7 +23,6 @@ -----------------------------------------------------------------------------  {-# LANGUAGE DeriveAnyClass        #-}-{-# LANGUAGE DeriveFoldable        #-} {-# LANGUAGE DeriveGeneric         #-} {-# LANGUAGE DeriveTraversable     #-} {-# LANGUAGE FlexibleInstances     #-}
Documentation/SBV/Examples/ProofTools/Strengthen.hs view
@@ -29,7 +29,6 @@ -- in Bradley's paper quite closely. ----------------------------------------------------------------------------- -{-# LANGUAGE DeriveFoldable        #-} {-# LANGUAGE DeriveTraversable     #-} {-# LANGUAGE FlexibleInstances     #-} {-# LANGUAGE MultiParamTypeClasses #-}
Documentation/SBV/Examples/ProofTools/Sum.hs view
@@ -22,7 +22,6 @@ -----------------------------------------------------------------------------  {-# LANGUAGE DeriveAnyClass        #-}-{-# LANGUAGE DeriveFoldable        #-} {-# LANGUAGE DeriveGeneric         #-} {-# LANGUAGE DeriveTraversable     #-} {-# LANGUAGE FlexibleInstances     #-}
+ Documentation/SBV/Examples/Puzzles/AOC_2021_24.hs view
@@ -0,0 +1,442 @@+-----------------------------------------------------------------------------+-- |+-- Module    : Documentation.SBV.Examples.Puzzles.AOC_2021_24+-- Copyright : (c) Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- A solution to the advent-of-code problem, 2021, day 24: <http://adventofcode.com/2021/day/24>.+--+-- Here is a high-level summary: We are essentially modeling the ALU of a fictional+-- computer with 4 integer registers (w, x, y, z), and 6 instructions (inp, add, mul, div, mod, eql).+-- You are given a program (hilariously called "monad"), and your goal is to figure out what+-- the maximum and minimum inputs you can provide to this program such that when it runs+-- register z ends up with the value 1. Please refer to the above link for the full description.+--+-- While there are multiple ways to solve this problem in SBV, the solution here demonstrates+-- how to turn programs in this fictional language into actual Haskell/SBV programs, i.e.,+-- developing a little EDSL (embedded domain-specific language) for it. Hopefully this+-- should provide a template for other similar programs.+-----------------------------------------------------------------------------++{-# LANGUAGE NamedFieldPuns   #-}+{-# LANGUAGE NegativeLiterals #-}++{-# OPTIONS_GHC -Wall -Werror #-}++module Documentation.SBV.Examples.Puzzles.AOC_2021_24 where++import Prelude hiding (read, mod, div)++import Data.Maybe++import qualified Data.Map.Strict          as M+import qualified Control.Monad.State.Lazy as ST++import Data.SBV++-----------------------------------------------------------------------------------------------+-- * Registers, values, and the ALU+-----------------------------------------------------------------------------------------------++-- | A Register in the machine, identified by its name.+type Register = String++-- | We operate on 64-bit signed integers. It is also possible to use the unbounded integers here+-- as the problem description doesn't mention any size limitations. But performance isn't as good+-- with unbounded integers, and 64-bit signed bit-vectors seem to fit the bill just fine, much+-- like any other modern processor these days.+type Value = SInt64++-- | An item of data to be processed. We can either be referring to a named register, or an immediate value.+data Data = Reg {register :: Register}+          | Imm Int64++-- | 'Num' instance for 'Data'. This is merely there for us to be able to represent programs in a+-- natural way, i.e, lifting integers (positive and negative). Other methods are neither implemented+-- nor needed.+instance Num Data where+  fromInteger    = Imm . fromIntegral+  (+)            = error "+     : unimplemented"+  (*)            = error "*     : unimplemented"+  negate (Imm i) = Imm (-i)+  negate Reg{}   = error "negate: unimplemented"+  abs            = error "abs   : unimplemented"+  signum         = error "signum: unimplemented"++-- | Shorthand for the @w@ register.+w :: Data+w = Reg "w"++-- | Shorthand for the @x@ register.+x :: Data+x = Reg "x"++-- | Shorthand for the @y@ register.+y :: Data+y = Reg "y"++-- | Shorthand for the @z@ register.+z :: Data+z = Reg "z"++-- | The state of the machine. We keep track of the data values, along with the input parameters.+data State = State { env    :: M.Map Register Value  -- ^ Values of registers+                   , inputs :: [Value]               -- ^ Input parameters, stored in reverse.+                   }++-- | The ALU is simply a state transformer, manipulating the state, wrapped around SBV's 'Symbolic' monad.+type ALU = ST.StateT State Symbolic++-----------------------------------------------------------------------------------------------+-- * Operations+-----------------------------------------------------------------------------------------------++-- | Reading a value. For a register, we simply look it up in the environment.+-- For an immediate, we simply return it.+read :: Data -> ALU Value+read (Reg r) = ST.get >>= \st -> pure $ fromJust (r `M.lookup` env st)+read (Imm i) = pure $ literal i++-- | Writing a value. We update the registers.+write :: Data -> Value -> ALU ()+write d v = ST.modify' $ \st -> st{env = M.insert (register d) v (env st)}++-- | Reading an input value. In this version, we simply write a free symbolic value+-- to the specified register, and keep track of the inputs explicitly.+inp :: Data -> ALU ()+inp a = do v <- ST.lift free_+           write a v+           ST.modify' $ \st -> st{inputs = v : inputs st}++-- | Addition.+add :: Data -> Data -> ALU ()+add a b = write a =<< (+) <$> read a <*> read b++-- | Multiplication.+mul :: Data -> Data -> ALU ()+mul a b = write a =<< (*) <$> read a <*> read b++-- | Division.+div :: Data -> Data -> ALU ()+div a b = write a =<< sDiv <$> read a <*> read b++-- | Modulus.+mod :: Data -> Data -> ALU ()+mod a b = write a =<< sMod <$> read a <*> read b++-- | Equality.+eql :: Data -> Data -> ALU ()+eql a b = write a . oneIf =<< (.==) <$> read a <*> read b++-----------------------------------------------------------------------------------------------+-- * Running a program+-----------------------------------------------------------------------------------------------++-- | Run a given program, returning the final state. We simply start with the initial+-- environment mapping all registers to zero, as specified in the problem specification.+run :: ALU () -> Symbolic State+run pgm = ST.execStateT pgm initState+ where initState = State { env    = M.fromList [(register r, 0) | r <- [w, x, y, z]]+                         , inputs = []+                         }++-----------------------------------------------------------------------------------------------+-- * Solving the puzzle+--+-----------------------------------------------------------------------------------------------++-- | We simply run the 'monad' program, and specify the constraints at the end. We take a boolean+-- as a parameter, choosing whether we want to minimize or maximize the model-number. We have:+--+-- >>> puzzle True+-- Optimal model:+--   Maximum model number = 96918996924991 :: Int64+-- >>> puzzle False+-- Optimal model:+--   Minimum model number = 91811241911641 :: Int64+puzzle :: Bool -> IO ()+puzzle shouldMaximize = print =<< optimizeWith z3{isNonModelVar = (/= finalVar)}  Lexicographic problem+  where finalVar | shouldMaximize = "Maximum model number"+                 | True           = "Minimum model number"+        problem = do State{env, inputs} <- run monad++                     -- The final z value should be 0+                     constrain $ fromJust (register z `M.lookup` env) .== 0++                     -- Digits of the model number, stored in reverse+                     let digits = reverse inputs++                     -- Each digit is between 1-9+                     ST.forM_ digits $ \d -> constrain $ d `inRange` (1, 9)++                     -- Digits spell out the model number. We minimize/maximize this value as requested:+                     let modelNum = foldl (\sofar d -> 10 * sofar + d) 0 digits++                     -- maximize/minimize the digits as requested+                     if shouldMaximize+                        then maximize "goal" modelNum+                        else minimize "goal" modelNum++                     -- For display purposes, create a variable to assign to modelNum+                     modelNumV <- free finalVar+                     constrain $ modelNumV .== modelNum++-- | The program we need to crack. Note that different users get different programs on the Advent-Of-Code site, so this is simply one example.+-- You can simply cut-and-paste your version instead. (Don't forget the pragma @NegativeLiterals@ to GHC so @add x -1@ parses correctly as @add x (-1)@.)+monad :: ALU ()+monad = do inp w+           mul x 0+           add x z+           mod x 26+           div z 1+           add x 11+           eql x w+           eql x 0+           mul y 0+           add y 25+           mul y x+           add y 1+           mul z y+           mul y 0+           add y w+           add y 5+           mul y x+           add z y+           inp w+           mul x 0+           add x z+           mod x 26+           div z 1+           add x 13+           eql x w+           eql x 0+           mul y 0+           add y 25+           mul y x+           add y 1+           mul z y+           mul y 0+           add y w+           add y 5+           mul y x+           add z y+           inp w+           mul x 0+           add x z+           mod x 26+           div z 1+           add x 12+           eql x w+           eql x 0+           mul y 0+           add y 25+           mul y x+           add y 1+           mul z y+           mul y 0+           add y w+           add y 1+           mul y x+           add z y+           inp w+           mul x 0+           add x z+           mod x 26+           div z 1+           add x 15+           eql x w+           eql x 0+           mul y 0+           add y 25+           mul y x+           add y 1+           mul z y+           mul y 0+           add y w+           add y 15+           mul y x+           add z y+           inp w+           mul x 0+           add x z+           mod x 26+           div z 1+           add x 10+           eql x w+           eql x 0+           mul y 0+           add y 25+           mul y x+           add y 1+           mul z y+           mul y 0+           add y w+           add y 2+           mul y x+           add z y+           inp w+           mul x 0+           add x z+           mod x 26+           div z 26+           add x -1+           eql x w+           eql x 0+           mul y 0+           add y 25+           mul y x+           add y 1+           mul z y+           mul y 0+           add y w+           add y 2+           mul y x+           add z y+           inp w+           mul x 0+           add x z+           mod x 26+           div z 1+           add x 14+           eql x w+           eql x 0+           mul y 0+           add y 25+           mul y x+           add y 1+           mul z y+           mul y 0+           add y w+           add y 5+           mul y x+           add z y+           inp w+           mul x 0+           add x z+           mod x 26+           div z 26+           add x -8+           eql x w+           eql x 0+           mul y 0+           add y 25+           mul y x+           add y 1+           mul z y+           mul y 0+           add y w+           add y 8+           mul y x+           add z y+           inp w+           mul x 0+           add x z+           mod x 26+           div z 26+           add x -7+           eql x w+           eql x 0+           mul y 0+           add y 25+           mul y x+           add y 1+           mul z y+           mul y 0+           add y w+           add y 14+           mul y x+           add z y+           inp w+           mul x 0+           add x z+           mod x 26+           div z 26+           add x -8+           eql x w+           eql x 0+           mul y 0+           add y 25+           mul y x+           add y 1+           mul z y+           mul y 0+           add y w+           add y 12+           mul y x+           add z y+           inp w+           mul x 0+           add x z+           mod x 26+           div z 1+           add x 11+           eql x w+           eql x 0+           mul y 0+           add y 25+           mul y x+           add y 1+           mul z y+           mul y 0+           add y w+           add y 7+           mul y x+           add z y+           inp w+           mul x 0+           add x z+           mod x 26+           div z 26+           add x -2+           eql x w+           eql x 0+           mul y 0+           add y 25+           mul y x+           add y 1+           mul z y+           mul y 0+           add y w+           add y 14+           mul y x+           add z y+           inp w+           mul x 0+           add x z+           mod x 26+           div z 26+           add x -2+           eql x w+           eql x 0+           mul y 0+           add y 25+           mul y x+           add y 1+           mul z y+           mul y 0+           add y w+           add y 13+           mul y x+           add z y+           inp w+           mul x 0+           add x z+           mod x 26+           div z 26+           add x -13+           eql x w+           eql x 0+           mul y 0+           add y 25+           mul y x+           add y 1+           mul z y+           mul y 0+           add y w+           add y 6+           mul y x+           add z y++{-# ANN module ("HLint: ignore Reduce duplication" :: String) #-}
Documentation/SBV/Examples/Puzzles/Birthday.hs view
@@ -36,7 +36,7 @@ -- NB. Thanks to Amit Goel for suggesting the formalization strategy used in here. ----------------------------------------------------------------------------- -{-# OPTIONS_GHC -Wall -Werror #-}+{-# OPTIONS_GHC -Wall -Werror -Wno-incomplete-uni-patterns #-}  module Documentation.SBV.Examples.Puzzles.Birthday where @@ -100,8 +100,8 @@ -- assert the conversation line-by-line, and see how the search-space gets reduced in each -- step. puzzle :: Predicate-puzzle = do birthDay   <- exists "birthDay"-            birthMonth <- exists "birthMonth"+puzzle = do birthDay   <- sbvExists "birthDay"+            birthMonth <- sbvExists "birthMonth"              -- Albert: I do not know             let a1 m = existsDay $ \d1 -> existsDay $ \d2 ->
Documentation/SBV/Examples/Puzzles/Coins.hs view
@@ -42,7 +42,7 @@ -- | Create a coin. The argument Int argument just used for naming the coin. Note that -- we constrain the value to be one of the valid U.S. coin values as we create it. mkCoin :: Int -> Symbolic Coin-mkCoin i = do c <- exists $ 'c' : show i+mkCoin i = do c <- sbvExists $ 'c' : show i               constrain $ sAny (.== c) [1, 5, 10, 25, 50, 100]               return c
+ Documentation/SBV/Examples/Puzzles/Drinker.hs view
@@ -0,0 +1,73 @@+-----------------------------------------------------------------------------+-- |+-- Module    : Documentation.SBV.Examples.Puzzles.Drinker+-- Copyright : (c) Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- SBV proof of the drinker paradox: <http://en.wikipedia.org/wiki/Drinker_paradox>+--+-- Let P be the non-empty set of people in a bar. The theorem says if there is somebody drinking in the bar,+-- then everybody is drinking in the bar. The general formulation is:+--+-- @+--     ∃x : P. D(x) -> ∀y : P. D(y)+-- @+--+-- In SBV, quantifiers are allowed, but you need to put the formula into prenex normal form manually. See+-- <http://en.wikipedia.org/wiki/Prenex_normal_form> for details. (Note that you do not need to do skolemization+-- by hand, though SBV will do that for you automatically as well as it casts the problem into an SMT query.)+-- If we transform the above to prenex form, we get:+--+-- @+--     ∃x : P. ∀y : P. D(x) -> D(y)+-- @+--+-- In this file, we show two different ways of proving the above in SBV; one using the monadic style,+-- and the other using the expression style.+-----------------------------------------------------------------------------++{-# LANGUAGE DeriveAnyClass     #-}+{-# LANGUAGE DeriveDataTypeable #-}+{-# LANGUAGE StandaloneDeriving #-}+{-# LANGUAGE TemplateHaskell    #-}++{-# OPTIONS_GHC -Wall -Werror #-}++module Documentation.SBV.Examples.Puzzles.Drinker where++import Data.SBV++-- | Declare a carrier data-type in Haskell named P, representing all the people in a bar.+data P++-- | Make 'P' an uninterpreted sort, introducing the type 'SP' for its symbolic version+mkUninterpretedSort ''P++-- | Declare the uninterpret function 'd', standing for drinking. For each person, this function+-- assigns whether they are drinking; but is otherwise completely uninterpreted. (i.e., our theorem+-- will be true for all such functions.)+d :: SP -> SBool+d = uninterpret "D"++-- | Monadic formulation. In this style, we use the 'sbvExists' and 'sbvForall' constructs to create+-- our quantified variables. We have:+--+-- >>> drinker1+-- Q.E.D.+drinker1 :: IO ThmResult+drinker1 = prove $ do x <- sbvExists "x"+                      y <- sbvForall "y"++                      pure $ d x .=> d y++-- | Expression level formulation. In this style, we use the 'existential' and 'universal' functions instead.+-- We have:+--+-- >>> drinker2+-- Q.E.D.+drinker2 :: IO ThmResult+drinker2 = prove $ existential ["x"] $ \x ->+                     universal ["y"] $ \y ->+                        d x .=> d y
Documentation/SBV/Examples/Puzzles/Garden.hs view
@@ -74,15 +74,15 @@             -- Declare three existential flowers. We declare these with             -- _modelIgnore suffix, because we don't care different assignments             -- to them to be a different model. See 'isNonModelVar' below.-            ef1 <- exists "ef1_modelIgnore"-            ef2 <- exists "ef2_modelIgnore"-            ef3 <- exists "ef3_modelIgnore"+            ef1 <- sbvExists "ef1_modelIgnore"+            ef2 <- sbvExists "ef2_modelIgnore"+            ef3 <- sbvExists "ef3_modelIgnore"              -- Declare three universal flowers to aid in encoding the             -- statements made by students.-            af1 <- forall "af1"-            af2 <- forall "af2"-            af3 <- forall "af3"+            af1 <- sbvForall "af1"+            af2 <- sbvForall "af2"+            af3 <- sbvForall "af3"              -- Each color is represented:             constrain $ valid ef1 ef2 ef3
Documentation/SBV/Examples/Puzzles/HexPuzzle.hs view
@@ -133,8 +133,8 @@ -- Searching at depth: 4 -- Searching at depth: 5 -- Searching at depth: 6--- Found: [10,10,9,11,14,6] -- Found: [10,10,11,9,14,6]+-- Found: [10,10,9,11,14,6] -- There are no more solutions. example :: IO () example = search initBoard finalBoard
+ Documentation/SBV/Examples/Puzzles/Jugs.hs view
@@ -0,0 +1,115 @@+-----------------------------------------------------------------------------+-- |+-- Module    : Documentation.SBV.Examples.Puzzles.Jugs+-- Copyright : (c) Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Solves the classic water jug puzzle: We have 3 jugs. The capacity of the jugs are 8, 5,+-- and 3 gallons. We begin with the 8 gallon jug full, the other two empty. We can transfer+-- from any jug to any other, completely topping off the latter. We want to end with+-- 4 gallons of water in the first and second jugs, and with an empty third jug. What+-- moves should we execute in order to do so?+-----------------------------------------------------------------------------++{-# LANGUAGE DeriveAnyClass #-}+{-# LANGUAGE DeriveGeneric  #-}++{-# OPTIONS_GHC -Wall -Werror #-}++module Documentation.SBV.Examples.Puzzles.Jugs where++import Data.SBV+import Data.SBV.Control++import GHC.Generics(Generic)++-- | A Jug has a capacity (i.e., maximum amount of water it can hold), and content, showing how much+-- it currently has. The invariant is that content is always non-negative and is at most the capacity.+data Jug = Jug { capacity :: Integer+               , content  :: SInteger+               } deriving (Generic, Mergeable)++-- | Transfer from one jug to another. By definition,+-- we transfer to fill the second jug, which may end up+-- filling it fully, or leaving some in the first jug.+transfer :: Jug -> Jug -> (Jug, Jug)+transfer j1 j2 = (j1', j2')+  where empty         = literal (capacity j2) - content j2+        transferrable = empty `smin` content j1+        j1'           = j1 { content = content j1 - transferrable }+        j2'           = j2 { content = content j2 + transferrable }++-- | At the beginning, we have an full 8-gallon jug, and two empty jugs, 5 and 3 gallons each.+initJugs :: (Jug, Jug, Jug)+initJugs = (j1, j2, j3)+  where j1 = Jug 8 8+        j2 = Jug 5 0+        j3 = Jug 3 0++-- | We've solved the puzzle if 8 and 5 gallon jugs have 4 gallons each, and the third one is empty.+solved :: (Jug, Jug, Jug) -> SBool+solved (j1, j2, j3) = content j1 .== 4 .&& content j2 .== 4 .&& content j3 .== 0++-- | Execute a bunch of moves.+moves :: [(SInteger, SInteger)] -> (Jug, Jug, Jug)+moves = foldl move initJugs+  where move :: (Jug, Jug, Jug) -> (SInteger, SInteger) -> (Jug, Jug, Jug)+        move (j0, j1, j2) (from, to) =+              ite ((from, to) .== (1, 2)) (let (j0', j1') = transfer j0 j1 in (j0', j1', j2))+            $ ite ((from, to) .== (2, 1)) (let (j1', j0') = transfer j1 j0 in (j0', j1', j2))+            $ ite ((from, to) .== (1, 3)) (let (j0', j2') = transfer j0 j2 in (j0', j1,  j2'))+            $ ite ((from, to) .== (3, 1)) (let (j2', j0') = transfer j2 j0 in (j0', j1,  j2'))+            $ ite ((from, to) .== (2, 3)) (let (j1', j2') = transfer j1 j2 in (j0,  j1', j2'))+            $ ite ((from, to) .== (3, 2)) (let (j2', j1') = transfer j2 j1 in (j0,  j1', j2'))+                                          (j0, j1, j2)++-- | Solve the puzzle. We have:+--+-- >>> puzzle+-- # of moves: 0+-- # of moves: 1+-- # of moves: 2+-- # of moves: 3+-- # of moves: 4+-- # of moves: 5+-- # of moves: 6+-- # of moves: 7+-- 1 --> 2+-- 2 --> 3+-- 3 --> 1+-- 2 --> 3+-- 1 --> 2+-- 2 --> 3+-- 3 --> 1+--+-- Here's the contents in terms of gallons after each move:+-- (8, 0, 0)+-- (3, 5, 0)+-- (3, 2, 3)+-- (6, 2, 0)+-- (6, 0, 2)+-- (1, 5, 2)+-- (1, 4, 3)+-- (4, 4, 0)+--+-- Note that by construction this is the minimum length solution. (Though our construction+-- does not guarantee that it is unique.)+puzzle :: IO ()+puzzle = runSMT $ do+            let run i = do io $ putStrLn $ "# of moves: " ++ show (i :: Int)+                           push 1+                           ms <- mapM (const genMove) [1..i]+                           constrain $ solved $ moves ms+                           cs <- checkSat+                           case cs of+                             Unsat -> do pop 1+                                         run (i+1)+                             Sat   -> mapM_ sh ms+                             _     -> error $ "Unexpected result: " ++ show cs+            query $ run 0+  where genMove = (,) <$> freshVar_ <*> freshVar_+        sh (f, t) = do from <- getValue f+                       to   <- getValue t+                       io $ putStrLn $ show from ++ " --> " ++ show to
Documentation/SBV/Examples/Puzzles/Murder.hs view
@@ -85,11 +85,11 @@ -- | Solve the puzzle. We have: -- -- >>> killer--- Alice     47  Bar    Female  Bystander--- Husband   46  Beach  Male    Killer--- Brother   47  Beach  Male    Victim+-- Alice     48  Bar    Female  Bystander+-- Husband   47  Beach  Male    Killer+-- Brother   48  Beach  Male    Victim -- Daughter  20  Alone  Female  Bystander--- Son       20  Bar    Male    Bystander+-- Son       21  Bar    Male    Bystander -- -- That is, Alice's brother was the victim and Alice's husband was the killer. killer :: IO ()@@ -99,7 +99,7 @@        cwidths  = map ((+2) . maximum . map length) (transpose wps)        align xs = concat $ zipWith (\i f -> take i (f ++ repeat ' ')) cwidths xs        trim     = reverse . dropWhile isSpace . reverse-   mapM_ putStrLn $ map (trim . align) wps+   mapM_ (putStrLn . trim . align) wps  -- | Constraints of the puzzle, coded following the English description. puzzle :: IO [Person Const]
Documentation/SBV/Examples/Puzzles/U2Bridge.hs view
@@ -16,7 +16,7 @@ {-# LANGUAGE StandaloneDeriving   #-} {-# LANGUAGE TemplateHaskell      #-} -{-# OPTIONS_GHC -Wall -Werror #-}+{-# OPTIONS_GHC -Wall -Werror -Wno-incomplete-uni-patterns #-}  module Documentation.SBV.Examples.Puzzles.U2Bridge where @@ -209,9 +209,9 @@ -- | See if there is a solution that has precisely @n@ steps solveN :: Int -> IO Bool solveN n = do putStrLn $ "Checking for solutions with " ++ show n ++ " move" ++ plu n ++ "."-              let genAct = do b  <- exists_-                              p1 <- exists_-                              p2 <- exists_+              let genAct = do b  <- sbvExists_+                              p1 <- sbvExists_+                              p2 <- sbvExists_                               return (b, p1, p2)               res <- allSat $ isValid `fmap` mapM (const genAct) [1..n]               cnt <- displayModels (sortOn show) disp res
Documentation/SBV/Examples/Queries/Concurrency.hs view
@@ -50,9 +50,9 @@ -- for demonstration purposes queryOne :: MVar (SInteger, SInteger) -> Query (Maybe Integer) queryOne v = do-  io $ putStrLn $ "[One]: Waiting"+  io $ putStrLn "[One]: Waiting"   liftIO $ threadDelay 5000000-  io $ putStrLn $ "[One]: Done"+  io $ putStrLn "[One]: Done"   (x,y) <- liftIO $ takeMVar v   constrain $ x .< y @@ -92,11 +92,11 @@ demo :: IO () demo = do   v <- newEmptyMVar-  putStrLn $ "[Main]: Hello from main, kicking off children: "+  putStrLn "[Main]: Hello from main, kicking off children: "   results <- satConcurrentWithAll z3 [queryOne v, queryTwo v] (shared v)-  putStrLn $ "[Main]: Children spawned, waiting for results"-  putStrLn $ "[Main]: Here they are: "-  putStrLn $ show results+  putStrLn "[Main]: Children spawned, waiting for results"+  putStrLn "[Main]: Here they are: "+  print results  -- | Example computation. sharedDependent :: MVar (SInteger, SInteger) -> Symbolic ()@@ -117,7 +117,7 @@ firstQuery :: MVar (SInteger, SInteger) -> MVar (SInteger , SInteger) -> Query (Maybe Integer) firstQuery v1 v2 = do   (x,y) <- liftIO $ takeMVar v1-  io $ putStrLn $ "[One]: got vars...working..."+  io $ putStrLn "[One]: got vars...working..."   constrain $ x .< y    cs <- checkSat@@ -130,7 +130,7 @@     Sat    -> do xv <- getValue x                  yv <- getValue y                  io $ putStrLn $ "[One]: Current solution is: " ++ show (xv, yv)-                 io $ putStrLn $ "[One]: Place vars for [Two]"+                 io $ putStrLn   "[One]: Place vars for [Two]"                  liftIO $ putMVar v2 (literal (xv + yv), literal (xv * yv))                  return $ Just (xv + yv) @@ -172,3 +172,5 @@   v2 <- newEmptyMVar   results <- satConcurrentWithAll z3 [firstQuery v1 v2, secondQuery v2] (sharedDependent v1)   print results++{-# ANN module ("HLint: ignore Reduce duplication" :: String) #-}
Documentation/SBV/Examples/Queries/Interpolants.hs view
@@ -21,6 +21,11 @@ import Data.SBV import Data.SBV.Control +-- $setup+-- >>> -- For doctest purposes only:+-- >>> import Data.SBV+-- >>> import Data.SBV.Control+ -- | MathSAT example. Compute the interpolant for the following sets of formulas: -- --     @{x - 3y >= -1, x + y >= 0}@@@ -120,3 +125,5 @@        z <- sInteger "z"         query $ getInterpolantZ3 [y .== 2*x, y .== 2*z+1]++{-# ANN module ("HLint: ignore Reduce duplication" :: String) #-}
Documentation/SBV/Examples/Strings/RegexCrossword.hs view
@@ -20,7 +20,9 @@ import Data.SBV import Data.SBV.Control -import Data.SBV.String ((.!!))+import Prelude hiding ((!!))+import Data.SBV.String ((!!))+ import qualified Data.SBV.String as S import qualified Data.SBV.RegExp as R @@ -47,8 +49,8 @@         cols <- mapM mkCol colRegExps          -- constrain each "cell" as they rows/columns intersect:-        let rowss =           [[r .!! literal i | i <- [0..numCols-1]] | r <- rows]-        let colss = transpose [[c .!! literal i | i <- [0..numRows-1]] | c <- cols]+        let rowss =           [[r !! literal i | i <- [0..numCols-1]] | r <- rows]+        let colss = transpose [[c !! literal i | i <- [0..numRows-1]] | c <- cols]          constrain $ sAnd $ zipWith (.==) (concat rowss) (concat colss)
Documentation/SBV/Examples/Strings/SQLInjection.hs view
@@ -26,7 +26,8 @@ import Data.SBV import Data.SBV.Control -import Data.SBV.String ((.++))+import Prelude hiding ((++))+import Data.SBV.String ((++)) import qualified Data.SBV.RegExp as R  -- | Simple expression language@@ -47,9 +48,9 @@ eval :: SQLExpr -> M SString eval (Query q)         = do q' <- eval q                             tell [q']-                            lift $ lift exists_+                            lift $ lift sbvExists_ eval (Const str)       = return $ literal str-eval (Concat e1 e2)    = (.++) <$> eval e1 <*> eval e2+eval (Concat e1 e2)    = (++) <$> eval e1 <*> eval e2 eval (ReadVar nm)      = do n   <- eval nm                             arr <- get                             return $ readArray arr n
Documentation/SBV/Examples/Transformers/SymbolicEval.hs view
@@ -20,6 +20,7 @@ -- named @x@ and @y@. ----------------------------------------------------------------------------- +{-# LANGUAGE CPP                        #-} {-# LANGUAGE DeriveFunctor              #-} {-# LANGUAGE GADTs                      #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-}@@ -38,9 +39,15 @@  import Data.SBV.Dynamic   (SVal) import Data.SBV.Internals (SBV(SBV), unSBV)-import Data.SBV.Trans import Data.SBV.Trans.Control +-- Starting with base 4.16; Data.Bits exports And, which conflicts with the definition here+#if MIN_VERSION_base(4,16,0)+import Data.SBV.Trans hiding(And)+#else+import Data.SBV.Trans+#endif+ -- * Allocation of symbolic variables, so we can extract a model later.  -- | Monad for allocating free variables.@@ -180,11 +187,11 @@  -- * Some examples --- | Check that @x+y+1@ generates a counter-example for the property that the+-- | Check that @x+1+y@ generates a counter-example for the property that the -- result is less than @10@ when @x+y@ is at least @9@. We have: -- -- >>> ex1--- Right (Counterexample 0 9)+-- Right (Counterexample 9 0) ex1 :: IO (Either String CheckResult) ex1 = check (Program  $ Var "x" `Plus` Lit 1 `Plus` Var "y")             (Property $ Var "result" `LessThan` Lit 10)
Documentation/SBV/Examples/Uninterpreted/Function.hs view
@@ -15,6 +15,10 @@  import Data.SBV +-- $setup+-- >>> -- For doctest purposes only:+-- >>> import Data.SBV+ -- | An uninterpreted function f :: SWord8 -> SWord8 -> SWord16 f = uninterpret "f"
Documentation/SBV/Examples/Uninterpreted/Multiply.hs view
@@ -12,12 +12,16 @@  {-# LANGUAGE ScopedTypeVariables #-} -{-# OPTIONS_GHC -Wall -Werror #-}+{-# OPTIONS_GHC -Wall -Werror -Wno-incomplete-uni-patterns #-}  module Documentation.SBV.Examples.Uninterpreted.Multiply where  import Data.SBV +-- $setup+-- >>> -- For doctest purposes only:+-- >>> import Data.SBV+ -- | The uninterpreted implementation of our 2x2 multiplier. We simply -- receive two 2-bit values, and return the high and the low bit of the -- resulting multiplication via two uninterpreted functions that we@@ -34,7 +38,6 @@   where mul22_hi = uninterpret "mul22_hi" a1 a0 b1 b0         mul22_lo = uninterpret "mul22_lo"    a0    b0 - -- | Synthesize a 2x2 multiplier. We use 8-bit inputs merely because that is -- the lowest bit-size SBV supports but that is more or less irrelevant. (Larger -- sizes would work too.) We simply assert this for all input values, extract@@ -44,12 +47,12 @@ -- >>> sat synthMul22 -- Satisfiable. Model: --   mul22_hi :: Bool -> Bool -> Bool -> Bool -> Bool---   mul22_hi False True  True  False = True---   mul22_hi False True  True  True  = True --   mul22_hi True  False False True  = True---   mul22_hi True  False True  True  = True --   mul22_hi True  True  False True  = True+--   mul22_hi False True  True  True  = True+--   mul22_hi False True  True  False = True --   mul22_hi True  True  True  False = True+--   mul22_hi True  False True  True  = True --   mul22_hi _     _     _     _     = False -- <BLANKLINE> --   mul22_lo :: Bool -> Bool -> Bool@@ -59,27 +62,29 @@ -- It is easy to see that the low bit is simply the logical-and of the low bits. It takes a moment of -- staring, but you can see that the high bit is correct as well: The logical formula is @a1b xor a0b1@, -- and if you work out the truth-table presented, you'll see that it is exactly that. Of course,--- you can use SBV to prove this. First, define the model we were given to make it symbolic:+-- you can use SBV to prove this. First, let's define the function we have synthesized  into a symbolic+-- function: ------ mul22_hi :: SBool -> SBool -> SBool -> SBool -> SBool--- mul22_hi a1 a0 b1 b0 = ite ([a1, a0, b1, b0] .== [sFalse, sTrue , sTrue , sFalse]) sTrue---                      $ ite ([a1, a0, b1, b0] .== [sFalse, sTrue , sTrue , sTrue ]) sTrue---                      $ ite ([a1, a0, b1, b0] .== [sTrue , sFalse, sFalse, sTrue ]) sTrue---                      $ ite ([a1, a0, b1, b0] .== [sTrue , sFalse, sTrue , sTrue ]) sTrue---                      $ ite ([a1, a0, b1, b0] .== [sTrue , sTrue , sFalse, sTrue ]) sTrue---                      $ ite ([a1, a0, b1, b0] .== [sTrue , sTrue , sTrue , sFalse]) sTrue---                        sFalse- >>> :{+-- >>> :{+-- mul22_hi :: (SBool, SBool, SBool, SBool) -> SBool+-- mul22_hi params = params `sElem` [ (sTrue,  sFalse, sFalse, sTrue )+--                                  , (sTrue,  sTrue , sFalse, sTrue )+--                                  , (sFalse, sTrue , sTrue , sTrue )+--                                  , (sFalse, sTrue , sTrue , sFalse)+--                                  , (sTrue , sTrue , sTrue , sFalse)+--                                  , (sTrue , sFalse, sTrue , sTrue )+--                                  ] -- :} -- -- Now we can say: ----- >>> prove $ \a1 a0 b1 b0 -> mul22_hi a1 a0 b1 b0 .== (a1 .&& b0) .<+> (a0 .&& b1)+-- >>> prove $ \a1 a0 b1 b0 -> mul22_hi (a1, a0, b1, b0) .== (a1 .&& b0) .<+> (a0 .&& b1) -- Q.E.D. -- -- and rest assured that we have a correctly synthesized circuit! synthMul22 :: Goal-synthMul22 = do a :: SWord8 <- forall "a"-                b :: SWord8 <- forall "b"+synthMul22 = do a :: SWord8 <- sbvForall "a"+                b :: SWord8 <- sbvForall "b"                  let lsb2 x = let [x1, x0] = reverse $ take 2 $ blastLE x                              in (x1, x0)
Documentation/SBV/Examples/Uninterpreted/Shannon.hs view
@@ -14,7 +14,7 @@  module Documentation.SBV.Examples.Uninterpreted.Shannon where -import Data.SBV+import Data.SBV hiding (universal, existential)  ----------------------------------------------------------------------------- -- * Boolean functions
Documentation/SBV/Examples/Uninterpreted/UISortAllSat.hs view
@@ -21,6 +21,10 @@  import Data.SBV +-- $setup+-- >>> -- For doctest purposes only:+-- >>> import Data.SBV+ -- | A "list-like" data type, but one we plan to uninterpret at the SMT level. -- The actual shape is really immaterial for us. data L
Documentation/SBV/Examples/WeakestPreconditions/Append.hs view
@@ -25,7 +25,10 @@ import Data.SBV import Data.SBV.Control -import           Data.SBV.List ((.++))+import Prelude hiding ((++))+import qualified Prelude as P++import           Data.SBV.List ((++)) import qualified Data.SBV.List as L  import Data.SBV.Tools.WeakestPreconditions@@ -49,14 +52,12 @@ -- | Show instance for 'AppS'. The above deriving clause would work just as well, -- but we want it to be a little prettier here, and hence the @OVERLAPS@ directive. instance {-# OVERLAPS #-} (SymVal a, Show a) => Show (AppS a) where-  show (AppS xs ys ts zs) = "{xs = " ++ sh xs ++ ", ys = " ++ sh ys ++ ", ts = " ++ sh ts ++ ", zs = " ++ sh zs ++ "}"-    where sh v = case unliteral v of-                   Nothing -> "<symbolic>"-                   Just i  -> show i+  show (AppS xs ys ts zs) = "{xs = " P.++ sh xs P.++ ", ys = " P.++ sh ys P.++ ", ts = " P.++ sh ts P.++ ", zs = " P.++ sh zs P.++ "}"+    where sh v = maybe "<symbolic>" show (unliteral v)  -- | Show instance, a bit more prettier than what would be derived: instance Show a => Show (AppC a) where-  show (AppC xs ys ts zs) = "{xs = " ++ show xs ++ ", ys = " ++ show ys ++ ", ts = " ++ show ts ++ ", zs = " ++ show zs ++ "}"+  show (AppC xs ys ts zs) = "{xs = " P.++ show xs P.++ ", ys = " P.++ show ys P.++ ", ts = " P.++ show ts P.++ ", zs = " P.++ show zs P.++ "}"  -- | 'Queriable' instance for the program state instance Queriable IO (AppS Integer) (AppC Integer) where@@ -85,11 +86,11 @@ algorithm :: Stmt A algorithm = Seq [ Assign $ \st          -> st{zs = []}                 , Assign $ \st@AppS{xs} -> st{ts = xs}-                , loop "xs" (\AppS{xs, zs, ts} -> xs .== zs .++ ts)+                , loop "xs" (\AppS{xs, zs, ts} -> xs .== zs ++ ts)                 , Assign $ \st@AppS{ys} -> st{ts = ys}-                , loop "ys" (\AppS{xs, ys, zs, ts} -> xs .++ ys .== zs .++ ts)+                , loop "ys" (\AppS{xs, ys, zs, ts} -> xs ++ ys .== zs ++ ts)                 ]-  where loop w inv = While ("walk over " ++ w)+  where loop w inv = While ("walk over " P.++ w)                            inv                            (Just (\AppS{ts} -> [L.length ts]))                            (\AppS{ts} -> sNot (L.null ts))@@ -107,7 +108,7 @@                            }   where -- We must append properly!         postcondition :: A -> SBool-        postcondition AppS{xs, ys, zs} = zs .== xs .++ ys+        postcondition AppS{xs, ys, zs} = zs .== xs ++ ys          -- Program should never change values of @xs@ and @ys@         noChange = [stable "xs" xs, stable "ys" ys]
Documentation/SBV/Examples/WeakestPreconditions/Basics.hs view
@@ -12,7 +12,6 @@ -----------------------------------------------------------------------------  {-# LANGUAGE DeriveAnyClass        #-}-{-# LANGUAGE DeriveFoldable        #-} {-# LANGUAGE DeriveGeneric         #-} {-# LANGUAGE DeriveTraversable     #-} {-# LANGUAGE FlexibleInstances     #-}@@ -30,6 +29,12 @@  import GHC.Generics (Generic) +-- $setup+-- >>> -- For doctest purposes only:+-- >>> import Data.SBV+-- >>> import Data.SBV.Control+-- >>> import Data.SBV.Tools.WeakestPreconditions+ -- * Program state  -- | The state for the swap program, parameterized over a base type @a@.@@ -42,9 +47,7 @@ -- but we want it to be a little prettier here, and hence the @OVERLAPS@ directive. instance {-# OVERLAPS #-} (SymVal a, Show a) => Show (IncS (SBV a)) where    show (IncS x y) = "{x = " ++ sh x ++ ", y = " ++ sh y ++ "}"-     where sh v = case unliteral v of-                    Nothing -> "<symbolic>"-                    Just l  -> show l+     where sh v = maybe "<symbolic>" show (unliteral v)  -- | 'Fresh' instance for the program state instance SymVal a => Fresh IO (IncS (SBV a)) where@@ -75,7 +78,7 @@ pre :: I -> SBool pre IncS{x} = x .>= 0 --- | Postcondition for our program: @y@ must @x+1@.+-- | Postcondition for our program: @y@ must equal @x+1@. post :: I -> SBool post IncS{x, y} = y .== x+1
Documentation/SBV/Examples/WeakestPreconditions/Fib.hs view
@@ -13,7 +13,6 @@ -----------------------------------------------------------------------------  {-# LANGUAGE DeriveAnyClass        #-}-{-# LANGUAGE DeriveFoldable        #-} {-# LANGUAGE DeriveGeneric         #-} {-# LANGUAGE DeriveTraversable     #-} {-# LANGUAGE FlexibleInstances     #-}@@ -31,6 +30,12 @@  import GHC.Generics (Generic) +-- $setup+-- >>> -- For doctest purposes only:+-- >>> import Data.SBV+-- >>> import Data.SBV.Control+-- >>> import Data.SBV.Tools.WeakestPreconditions+ -- * Program state  -- | The state for the sum program, parameterized over a base type @a@.@@ -45,9 +50,7 @@ -- but we want it to be a little prettier here, and hence the @OVERLAPS@ directive. instance {-# OVERLAPS #-} (SymVal a, Show a) => Show (FibS (SBV a)) where    show (FibS n i k m) = "{n = " ++ sh n ++ ", i = " ++ sh i ++ ", k = " ++ sh k ++ ", m = " ++ sh m ++ "}"-     where sh v = case unliteral v of-                    Nothing -> "<symbolic>"-                    Just l  -> show l+     where sh v = maybe "<symbolic>" show (unliteral v)  -- | 'Fresh' instance for the program state instance SymVal a => Fresh IO (FibS (SBV a)) where
Documentation/SBV/Examples/WeakestPreconditions/GCD.hs view
@@ -15,7 +15,6 @@ -----------------------------------------------------------------------------  {-# LANGUAGE DeriveAnyClass        #-}-{-# LANGUAGE DeriveFoldable        #-} {-# LANGUAGE DeriveGeneric         #-} {-# LANGUAGE DeriveTraversable     #-} {-# LANGUAGE FlexibleInstances     #-}@@ -37,6 +36,12 @@ import Prelude hiding (gcd) import qualified Prelude as P (gcd) +-- $setup+-- >>> -- For doctest purposes only:+-- >>> import Data.SBV+-- >>> import Data.SBV.Control+-- >>> import Data.SBV.Tools.WeakestPreconditions+ -- * Program state  -- | The state for the sum program, parameterized over a base type @a@.@@ -51,9 +56,7 @@ -- but we want it to be a little prettier here, and hence the @OVERLAPS@ directive. instance {-# OVERLAPS #-} (SymVal a, Show a) => Show (GCDS (SBV a)) where    show (GCDS x y i j) = "{x = " ++ sh x ++ ", y = " ++ sh y ++ ", i = " ++ sh i ++ ", j = " ++ sh j ++ "}"-     where sh v = case unliteral v of-                    Nothing -> "<symbolic>"-                    Just l  -> show l+     where sh v = maybe "<symbolic>" show (unliteral v)  -- | 'Fresh' instance for the program state instance SymVal a => Fresh IO (GCDS (SBV a)) where
Documentation/SBV/Examples/WeakestPreconditions/IntDiv.hs view
@@ -12,7 +12,6 @@ -----------------------------------------------------------------------------  {-# LANGUAGE DeriveAnyClass        #-}-{-# LANGUAGE DeriveFoldable        #-} {-# LANGUAGE DeriveGeneric         #-} {-# LANGUAGE DeriveTraversable     #-} {-# LANGUAGE FlexibleInstances     #-}@@ -44,9 +43,7 @@ -- but we want it to be a little prettier here, and hence the @OVERLAPS@ directive. instance {-# OVERLAPS #-} (SymVal a, Show a) => Show (DivS (SBV a)) where    show (DivS x y q r) = "{x = " ++ sh x ++ ", y = " ++ sh y ++ ", q = " ++ sh q ++ ", r = " ++ sh r ++ "}"-     where sh v = case unliteral v of-                    Nothing -> "<symbolic>"-                    Just l  -> show l+     where sh v = maybe "<symbolic>" show (unliteral v)  -- | 'Fresh' instance for the program state instance SymVal a => Fresh IO (DivS (SBV a)) where
Documentation/SBV/Examples/WeakestPreconditions/IntSqrt.hs view
@@ -14,7 +14,6 @@ -----------------------------------------------------------------------------  {-# LANGUAGE DeriveAnyClass        #-}-{-# LANGUAGE DeriveFoldable        #-} {-# LANGUAGE DeriveGeneric         #-} {-# LANGUAGE DeriveTraversable     #-} {-# LANGUAGE FlexibleInstances     #-}@@ -48,9 +47,7 @@ -- but we want it to be a little prettier here, and hence the @OVERLAPS@ directive. instance {-# OVERLAPS #-} (SymVal a, Show a) => Show (SqrtS (SBV a)) where    show (SqrtS x sqrt i j) = "{x = " ++ sh x ++ ", sqrt = " ++ sh sqrt ++ ", i = " ++ sh i ++ ", j = " ++ sh j ++ "}"-     where sh v = case unliteral v of-                    Nothing -> "<symbolic>"-                    Just l  -> show l+     where sh v = maybe "<symbolic>" show (unliteral v)  -- | 'Fresh' instance for the program state instance SymVal a => Fresh IO (SqrtS (SBV a)) where
Documentation/SBV/Examples/WeakestPreconditions/Length.hs view
@@ -50,9 +50,7 @@ -- | Show instance: A simplified version of what would otherwise be generated. instance (SymVal a, Show a) => Show (LenS a) where   show (LenS xs ys l) = "{xs = " ++ sh xs ++ ", ys = " ++ sh ys ++ ", l = " ++ sh l ++ "}"-    where sh v = case unliteral v of-                   Nothing -> "<symbolic>"-                   Just i  -> show i+    where sh v = maybe "<symbolic>" show (unliteral v)  -- | Show instance: Similarly, we want to be a bit more concise here. instance Show a => Show (LenC a) where
Documentation/SBV/Examples/WeakestPreconditions/Sum.hs view
@@ -12,7 +12,6 @@ -----------------------------------------------------------------------------  {-# LANGUAGE DeriveAnyClass        #-}-{-# LANGUAGE DeriveFoldable        #-} {-# LANGUAGE DeriveGeneric         #-} {-# LANGUAGE DeriveTraversable     #-} {-# LANGUAGE FlexibleInstances     #-}@@ -30,6 +29,10 @@  import GHC.Generics (Generic) +-- $setup+-- >>> -- For doctest purposes only:+-- >>> import Data.SBV+ -- * Program state  -- | The state for the sum program, parameterized over a base type @a@.@@ -43,9 +46,7 @@ -- but we want it to be a little prettier here, and hence the @OVERLAPS@ directive. instance {-# OVERLAPS #-} (SymVal a, Show a) => Show (SumS (SBV a)) where    show (SumS n i s) = "{n = " ++ sh n ++ ", i = " ++ sh i ++ ", s = " ++ sh s ++ "}"-     where sh v = case unliteral v of-                    Nothing -> "<symbolic>"-                    Just l  -> show l+     where sh v = maybe "<symbolic>" show (unliteral v)  -- | 'Fresh' instance for the program state instance SymVal a => Fresh IO (SumS (SBV a)) where@@ -181,17 +182,17 @@ ==================================   Postcondition fails:     Start: SumS {n = 0, i = 0, s = 0}-    End  : SumS {n = 0, i = 0, s = 1}+    End  : SumS {n = 0, i = 0, s = -1}  In this case, we are told that the end state does not establish the-post-condition. Indeed when @n=0@, we would expect @s=0@, not @s=1@.+post-condition. Indeed when @n=0@, we would expect @s=0@, not @s=-1@.  The natural question to ask is how did SBV come up with this unexpected state at the end of the program run? If you think about the program execution, indeed this state is unreachable: We know that @s@ represents the sum of all numbers up to @i@, so if @i=0@, we would expect @s@ to be @0@. Our invariant is clearly an overapproximation of the reachable space, and SBV is telling us that we need to constrain and outlaw-the state @{n = 0, i = 0, s = 1}@. Clearly, the invariant has to state something+the state @{n = 0, i = 0, s = -1}@. Clearly, the invariant has to state something about the relationship between @i@ and @s@, which we are missing in this case.  == Failing to maintain the invariant@@ -221,8 +222,8 @@ Following proof obligation failed: ==================================   Measure for loop "i < n" is negative:-    State  : SumS {n = 3, i = 2, s = 3}-    Measure: -2+    State  : SumS {n = 2, i = 1, s = 1}+    Measure: -1  The failure is pretty obvious in this case: Measure produces a negative value.
LICENSE view
@@ -1,6 +1,6 @@ SBV: SMT Based Verification in Haskell -Copyright (c) 2010-2021, Levent Erkok (erkokl@gmail.com)+Copyright (c) 2010-2022, Levent Erkok (erkokl@gmail.com) All rights reserved.  Redistribution and use in source and binary forms, with or without
SBVBenchSuite/BenchSuite/Bench/Bench.hs view
@@ -28,7 +28,6 @@   , runIO   , runPure   , rGroup-  , runOverheadBenchmark   , runBenchmark   , onConfig   , onDesc@@ -39,13 +38,8 @@   ) where  import           Control.DeepSeq         (NFData (..), rwhnf)-import           System.Directory        (getCurrentDirectory)-import           System.IO-import           System.IO.Silently      (silence) -import qualified Gauge.Main              as G--import qualified System.Process          as P+import qualified Test.Tasty.Bench        as B import qualified Utils.SBVBenchFramework as U  -- | The type of the problem to benchmark. This allows us to operate on Runners@@ -55,10 +49,6 @@ -- | Similarly to Problem, BenchResult is boilerplate for a nice api data BenchResult = forall a . (Show a, NFData a) => BenchResult a --- | A bench unit is a solver and a problem that represents an input problem--- for the solver to solve-type BenchUnit = (U.SMTConfig, FilePath)- -- | A runner is anything that allows the solver to solve, such as: -- 'Data.SBV.proveWith' or 'Data.SBV.satWith'. We utilize existential types to -- lose type information and create a unified interface with gauge. We@@ -69,7 +59,7 @@ -- useful because problems that require 'Data.SBV.allSatWith' can lead to a lot -- of variance in the benchmarking data. Single benchmark runners like -- 'Data.SBV.satWith' and 'Data.SBV.proveWith' work best.-data RunnerI = RunnerI { runI        :: (U.SMTConfig -> Problem -> IO BenchResult)+data RunnerI = RunnerI { runI        :: U.SMTConfig -> Problem -> IO BenchResult                        , config      :: U.SMTConfig                        , description :: String                        , problem     :: Problem@@ -79,9 +69,9 @@ -- so that we don't have to separate out runners that run a single benchmark -- from runners that need to run several benchmarks data Runner where-  RBenchmark  :: G.Benchmark -> Runner    -- ^ a wrapper around gauge benchmarks-  Runner      :: RunnerI   -> Runner      -- ^ a single run-  RunnerGroup :: [Runner]  -> Runner      -- ^ a group of runs+  RBenchmark  :: B.Benchmark -> Runner   -- ^ a wrapper around tasty-bench benchmarks+  Runner      :: RunnerI     -> Runner   -- ^ a single run+  RunnerGroup :: [Runner]    -> Runner   -- ^ a group of runs  -- | Convenience boilerplate functions, simply avoiding a lens dependency using :: Runner -> (Runner -> Runner) -> Runner@@ -117,7 +107,7 @@ {-# INLINE onDesc #-}  onProblem :: (forall a. a -> a) -> RunnerI -> RunnerI-onProblem f r@RunnerI{..} = r{problem = (helper problem)}+onProblem f r@RunnerI{..} = r{problem = helper problem}   where     -- helper function to avoid profunctor dependency, this is simply fmap, or     -- rmap for profunctor land@@ -125,88 +115,18 @@     helper (Problem p) = Problem $ f p {-# INLINE onProblem #-} ---- | Filepath to /dev/null-devNull :: FilePath-#ifdef mingw32_HOST_OS-devNull = "NUL"-#else-devNull = "/dev/null"-#endif---- | to bench a solver without interfacing through SBV we call transcript to--- have SBV generate the input file for the solver and then create a process to--- initiate execution on the solver. Note that we redirect stdout to /dev/devNull--- or NUL on windows-runStandaloneSolver :: BenchUnit -> IO ()-runStandaloneSolver (slvr, fname) =-  withFile devNull WriteMode $-  (\h -> do (_,_,_,ph) <- P.createProcess (P.shell command){P.std_out = P.UseHandle h}-            _ <- P.waitForProcess ph-            return ())-  where command = U.mkExecString slvr fname-{-# INLINE runStandaloneSolver #-}----- | Given a file name, a solver config, and a problem to solve, create an--- environment for the gauge benchmark by generating a transcript file-standaloneEnv :: RunnerI -> IO FilePath -> IO BenchUnit-standaloneEnv RunnerI{..} f = f >>= go problem-  where-    -- generate a transcript for the unit-    go p file = do pwd <- getCurrentDirectory-                   let fPath = mconcat [pwd,"/",file]-                   _ <- runI config{U.transcript = Just fPath} p >> return ()-                   return (config,fPath)-{-# INLINE standaloneEnv #-}---- | Cleanup the environment created by gauge by removing the transcript file--- used to run the standalone solver-standaloneCleanup :: BenchUnit -> IO ()-standaloneCleanup (_,fPath) =  P.callCommand $ "rm " ++ fPath-{-# INLINE standaloneCleanup #-}---- | To construct a benchmark to test SBV's overhead we setup an environment--- with gauge where a symbolic computation is emitted to a transcript file.--- To test the solver without respect to SBV (standalone) we pass the transcript--- file to the solver using the same primitives SBV does. Not that mkFileName--- generates a random filename that is removed at the end of the benchmark. This--- function exposes the solver and the solve interface in case the user would--- like to benchmark with something other than 'Data.SBV.z3' and so that we can--- benchmark all solving variants, e.g., 'Data.SBV.proveWith',--- 'Data.SBV.satWith', 'Data.SBV.allProveWith' etc.-mkOverheadBenchMark' :: RunnerI -> G.Benchmark-mkOverheadBenchMark' r@RunnerI{..} =-  G.envWithCleanup-  (standaloneEnv r U.mkFileName)-  standaloneCleanup $-  \ ~unit ->-    G.bgroup description [ G.bench "standalone" $! G.nfIO $ runStandaloneSolver unit-                         -- notice for sbv benchmark; we pull the solver out of unit and-                         -- use the input problem not the transcript in the unit-                         , G.bench "sbv"        $! G.nfIO $ runI (fst unit) problem-                         ]-{-# INLINE mkOverheadBenchMark' #-}--runOverheadBenchmark :: Runner -> G.Benchmark-runOverheadBenchmark (Runner r@RunnerI{}) = mkOverheadBenchMark' r-runOverheadBenchmark (RunnerGroup rs)     = G.bgroup "" $ -- leave the description close to the benchmark/problem definition-                                            runOverheadBenchmark <$> rs-runOverheadBenchmark (RBenchmark b)       = b-{-# INLINE runOverheadBenchmark #-}- -- | make a normal benchmark without the overhead comparison. Notice this is -- just unpacking the Runner record-mkBenchmark :: RunnerI -> G.Benchmark-mkBenchmark RunnerI{..} = G.bench description . G.nfIO $! runI config problem+mkBenchmark :: RunnerI -> B.Benchmark+mkBenchmark RunnerI{..} = B.bench description . B.nfIO $! runI config problem {-# INLINE  mkBenchmark #-}  -- | Convert a Runner or a group of Runners to Benchmarks, this is an api level -- function to convert the runners defined in each file to benchmarks which can -- be run by gauge-runBenchmark :: Runner -> G.Benchmark+runBenchmark :: Runner -> B.Benchmark runBenchmark (Runner r@RunnerI{}) = mkBenchmark r-runBenchmark (RunnerGroup rs)     = G.bgroup "" $ runBenchmark <$> rs+runBenchmark (RunnerGroup rs)     = B.bgroup "" $ runBenchmark <$> rs runBenchmark (RBenchmark b)       = b {-# INLINE runBenchmark #-} @@ -235,20 +155,20 @@ {-# INLINE run #-}  -- | Entry point for problems that return IO or to benchmark IO results-runIOWith :: NFData a => (a -> G.Benchmarkable) -> String -> a -> Runner-runIOWith f d = RBenchmark . G.bench d . f+runIOWith :: NFData a => (a -> B.Benchmarkable) -> String -> a -> Runner+runIOWith f d = RBenchmark . B.bench d . f {-# INLINE runIOWith #-}  -- | Benchmark an IO result of sbv, this could be codegen, return models, etc.. -- See @runIOWith@ for a version which allows the consumer to select the -- Benchmarkable injection function runIO :: NFData a => String -> IO a -> Runner-runIO d = RBenchmark . G.bench d . G.nfIO . silence+runIO d = RBenchmark . B.bench d . B.nfIO -- . silence {-# INLINE runIO #-}  -- | Benchmark an pure result runPure :: NFData a => String -> (a -> b) -> a -> Runner-runPure d = (RBenchmark . G.bench d) .: G.whnf+runPure d = (RBenchmark . B.bench d) .: B.whnf   where (.:) = (.).(.) {-# INLINE runPure  #-}
SBVBenchSuite/BenchSuite/BitPrecise/MultMask.hs view
@@ -23,9 +23,9 @@ benchmarks = rGroup   [ B.runWith conf "MultMask" find   ]-  where find = do mask <- exists "mask"-                  mult <- exists "mult"-                  inp  <- forall "inp"+  where find = do mask <- sbvExists "mask"+                  mult <- sbvExists "mult"+                  inp  <- sbvForall "inp"                   let res = (mask .&. inp) * (mult :: SWord64)                   solve [inp `sExtractBits` [7, 15 .. 63] .== res `sExtractBits` [56 .. 63]]         conf = z3{printBase=16, satCmd = "(check-sat-using (and-then simplify smtfd))"}
SBVBenchSuite/BenchSuite/Misc/Enumerate.hs view
@@ -31,9 +31,9 @@              ]   where _elts = \(x::SE) -> x .== x         _four = \a b c (d::SE) -> distinct [a, b, c, d]-        _maxE = do mx <- exists "maxE"-                   e  <- forall "e"+        _maxE = do mx <- sbvExists "maxE"+                   e  <- sbvForall "e"                    return $ mx .>= (e::SE)-        _minE = do mx <- exists "minE"-                   e  <- forall "e"+        _minE = do mx <- sbvExists "minE"+                   e  <- sbvForall "e"                    return $ mx .<= (e::SE)
SBVBenchSuite/BenchSuite/Optimization/ExtField.hs view
@@ -24,5 +24,5 @@ -- benchmark suite benchmarks :: Runner benchmarks = rGroup-             [ run "ExtField.problem" problem `using` runner (flip optimizeWith Lexicographic)+             [ run "ExtField.problem" problem `using` runner (`optimizeWith` Lexicographic)              ]
SBVBenchSuite/BenchSuite/Optimization/LinearOpt.hs view
@@ -23,4 +23,4 @@  -- benchmark suite benchmarks :: Runner-benchmarks = run "LinearOpt.problem" problem `using` runner (flip optimizeWith Lexicographic)+benchmarks = run "LinearOpt.problem" problem `using` runner (`optimizeWith` Lexicographic)
SBVBenchSuite/BenchSuite/Optimization/Production.hs view
@@ -23,4 +23,4 @@  -- benchmark suite benchmarks :: Runner-benchmarks = run "Production.production" production `using` runner (flip optimizeWith Lexicographic)+benchmarks = run "Production.production" production `using` runner (`optimizeWith` Lexicographic)
SBVBenchSuite/BenchSuite/Optimization/VM.hs view
@@ -23,4 +23,4 @@  -- benchmark suite benchmarks :: Runner-benchmarks = run "VM.allocate" allocate `using` runner (flip optimizeWith Lexicographic)+benchmarks = run "VM.allocate" allocate `using` runner (`optimizeWith` Lexicographic)
SBVBenchSuite/BenchSuite/Puzzles/Garden.hs view
@@ -15,7 +15,7 @@  module BenchSuite.Puzzles.Garden(benchmarks) where -import Data.Text (isSuffixOf)+import Data.List (isSuffixOf)  import Documentation.SBV.Examples.Puzzles.Garden
SBVBenchSuite/BenchSuite/Puzzles/U2Bridge.hs view
@@ -30,5 +30,5 @@   , S.run "U2Bridge_cnt6" (count 6) `using` runner satWith   ]   where-    act     = do b <- exists_; p1 <- exists_; p2 <- exists_; return (b, p1, p2)+    act     = do b <- sbvExists_; p1 <- sbvExists_; p2 <- sbvExists_; return (b, p1, p2)     count n = isValid `fmap` mapM (const act) [1..(n::Int)]
SBVBenchSuite/BenchSuite/Strings/RegexCrossword.hs view
@@ -21,7 +21,7 @@ -- benchmark suite benchmarks :: Runner benchmarks = rGroup-             [ runIO "puzzle1" $ puzzle1-             , runIO "puzzle2" $ puzzle2-             , runIO "puzzle3" $ puzzle3+             [ runIO "puzzle1" puzzle1+             , runIO "puzzle2" puzzle2+             , runIO "puzzle3" puzzle3              ]
SBVBenchSuite/BenchSuite/Uninterpreted/Shannon.hs view
@@ -16,7 +16,7 @@ module BenchSuite.Uninterpreted.Shannon(benchmarks) where  import Documentation.SBV.Examples.Uninterpreted.Shannon-import Data.SBV+import Data.SBV hiding (universal, existential)  import BenchSuite.Bench.Bench
SBVBenchSuite/BenchSuite/WeakestPreconditions/Fib.hs view
@@ -11,7 +11,6 @@ -----------------------------------------------------------------------------  {-# OPTIONS_GHC -Wall -Werror -fno-warn-orphans #-}-{-# LANGUAGE NamedFieldPuns #-}  module BenchSuite.WeakestPreconditions.Fib(benchmarks) where
SBVBenchSuite/BenchSuite/WeakestPreconditions/GCD.hs view
@@ -11,7 +11,6 @@ -----------------------------------------------------------------------------  {-# OPTIONS_GHC -Wall -Werror -fno-warn-orphans #-}-{-# LANGUAGE NamedFieldPuns #-}  module BenchSuite.WeakestPreconditions.GCD(benchmarks) where
SBVBenchSuite/BenchSuite/WeakestPreconditions/IntDiv.hs view
@@ -11,7 +11,6 @@ -----------------------------------------------------------------------------  {-# OPTIONS_GHC -Wall -Werror -fno-warn-orphans #-}-{-# LANGUAGE NamedFieldPuns #-}  module BenchSuite.WeakestPreconditions.IntDiv(benchmarks) where
SBVBenchSuite/BenchSuite/WeakestPreconditions/IntSqrt.hs view
@@ -11,7 +11,6 @@ -----------------------------------------------------------------------------  {-# OPTIONS_GHC -Wall -Werror -fno-warn-orphans #-}-{-# LANGUAGE NamedFieldPuns #-}  module BenchSuite.WeakestPreconditions.IntSqrt(benchmarks) where
SBVBenchSuite/BenchSuite/WeakestPreconditions/Length.hs view
@@ -11,7 +11,6 @@ -----------------------------------------------------------------------------  {-# OPTIONS_GHC -Wall -Werror -fno-warn-orphans #-}-{-# LANGUAGE NamedFieldPuns #-}  module BenchSuite.WeakestPreconditions.Length(benchmarks) where
SBVBenchSuite/SBVBench.hs view
@@ -7,54 +7,372 @@ -- Maintainer: erkokl@gmail.com -- Stability : experimental ----- We define this entry point to the benchsuite for use in fine-tuning SBV's--- performance. It may be the case that a user wants to benchmark only one--- particular feature or aspect of SBV and this entry point facilitates such a--- "deep dive".+-- Entry point to benchmark SBV. We define this as a separate cabal target so+-- that performance regressions can continue to occur as other fine-tuning+-- happens in parallel -----------------------------------------------------------------------------  module Main where -import           Gauge.Main.Options (defaultConfig, Config(..))+import           Test.Tasty hiding (defaultMain)+import           Test.Tasty.Bench --- import           Utils.SBVBenchFramework+import           BenchSuite.Bench.Bench -import Documentation.SBV.Examples.Puzzles.Counts+-- Puzzles+import qualified BenchSuite.Puzzles.Birthday+import qualified BenchSuite.Puzzles.Coins+-- import qualified BenchSuite.Puzzles.Counts -- see comment below+import qualified BenchSuite.Puzzles.DogCatMouse+-- import qualified BenchSuite.Puzzles.Euler185+import qualified BenchSuite.Puzzles.Garden+import qualified BenchSuite.Puzzles.LadyAndTigers+import qualified BenchSuite.Puzzles.MagicSquare+import qualified BenchSuite.Puzzles.NQueens+import qualified BenchSuite.Puzzles.SendMoreMoney+import qualified BenchSuite.Puzzles.Sudoku+-- import qualified BenchSuite.Puzzles.U2Bridge --- | Custom config to limit benchmarks to 5 minutes of runtime. This is required--- because we can easily generate benchmarks that take a lot of wall time to--- solve, especially with 'Data.SBV.allSatWith' calls-benchConfig :: Config-benchConfig = defaultConfig { timeLimit = Just 300.00 }+-- BitPrecise+import qualified BenchSuite.BitPrecise.BitTricks+-- import qualified BenchSuite.BitPrecise.BrokenSearch+-- import qualified BenchSuite.BitPrecise.Legato+-- import qualified BenchSuite.BitPrecise.MergeSort+import qualified BenchSuite.BitPrecise.MultMask+-- import qualified BenchSuite.BitPrecise.PrefixSum -{--This is the sister module to SBVBenchmark. Where SBVBenchmark provides the-continuous integration use case this module is reserved for deep dives into-particular aspects of SBV. One might use this entry point to only run a-particular benchmark of interest, or load and run a symbolic program to profile,-generate core code, or anything else. The workflow should be:+-- Queries+import qualified BenchSuite.Queries.AllSat+import qualified BenchSuite.Queries.CaseSplit+-- import qualified BenchSuite.Queries.Concurrency+import qualified BenchSuite.Queries.Enums+import qualified BenchSuite.Queries.FourFours+import qualified BenchSuite.Queries.GuessNumber+import qualified BenchSuite.Queries.Interpolants+import qualified BenchSuite.Queries.UnsatCore --------------------------------1. benchmark the code of interest-2. profile the code if you are looking for performance improvements-3. make your changes-4. repeat benchmark and profiling to confirm the effect of your changes-------------------------------+-- Weakest Preconditions+import qualified BenchSuite.WeakestPreconditions.Append+import qualified BenchSuite.WeakestPreconditions.Basics+import qualified BenchSuite.WeakestPreconditions.Fib+import qualified BenchSuite.WeakestPreconditions.GCD+import qualified BenchSuite.WeakestPreconditions.IntDiv+import qualified BenchSuite.WeakestPreconditions.IntSqrt+import qualified BenchSuite.WeakestPreconditions.Length+import qualified BenchSuite.WeakestPreconditions.Sum -We recommend using a special file name, e.g., `filename <- benchResultsFile-"mergeableTuning"` to hold the benchmarks so that the before and after results-can be compared in the usual way with BenchShow: `cabal repl SBVBench;-compareBenchMarksCli "SBVBenchSuite/BenchFiles/mergeableTuning.csv"`--}+-- Optimization+import qualified BenchSuite.Optimization.Enumerate+import qualified BenchSuite.Optimization.ExtField+import qualified BenchSuite.Optimization.LinearOpt+import qualified BenchSuite.Optimization.Production+import qualified BenchSuite.Optimization.VM +-- Uninterpreted+import qualified BenchSuite.Uninterpreted.AUF+import qualified BenchSuite.Uninterpreted.Deduce+import qualified BenchSuite.Uninterpreted.Function+import qualified BenchSuite.Uninterpreted.Multiply+import qualified BenchSuite.Uninterpreted.Shannon+import qualified BenchSuite.Uninterpreted.Sort+import qualified BenchSuite.Uninterpreted.UISortAllSat++-- Proof Tools+import qualified BenchSuite.ProofTools.BMC+import qualified BenchSuite.ProofTools.Fibonacci+import qualified BenchSuite.ProofTools.Strengthen+import qualified BenchSuite.ProofTools.Sum++-- Code Generation+import qualified BenchSuite.CodeGeneration.AddSub+import qualified BenchSuite.CodeGeneration.CRC_USB5+import qualified BenchSuite.CodeGeneration.Fibonacci+import qualified BenchSuite.CodeGeneration.GCD+import qualified BenchSuite.CodeGeneration.PopulationCount+import qualified BenchSuite.CodeGeneration.Uninterpreted++-- Crypto+import qualified BenchSuite.Crypto.AES+import qualified BenchSuite.Crypto.RC4+import qualified BenchSuite.Crypto.SHA++-- Miscellaneous+import qualified BenchSuite.Misc.Auxiliary+import qualified BenchSuite.Misc.Enumerate+-- import qualified BenchSuite.Misc.Floating+import qualified BenchSuite.Misc.ModelExtract+import qualified BenchSuite.Misc.Newtypes+import qualified BenchSuite.Misc.NoDiv0+-- import qualified BenchSuite.Misc.Polynomials+import qualified BenchSuite.Misc.SetAlgebra+import qualified BenchSuite.Misc.SoftConstrain+import qualified BenchSuite.Misc.Tuple++-- Lists+import qualified BenchSuite.Lists.BoundedMutex+import qualified BenchSuite.Lists.Fibonacci+import qualified BenchSuite.Lists.Nested++-- Strings+import qualified BenchSuite.Strings.RegexCrossword+import qualified BenchSuite.Strings.SQLInjection++-- Existentials+import qualified BenchSuite.Existentials.CRCPolynomial+import qualified BenchSuite.Existentials.Diophantine++-- Transformers+import qualified BenchSuite.Transformers.SymbolicEval+++{-+To benchmark sbv we require two use cases: For continuous integration we want a+snapshot of all benchmarks at a given point in time and we want to be able to+compare benchmarks over time for performance tuning. For this module we default+to the continuous integration flow. The workflow for fine grained performance+analysis is to run a benchmark, make your changes, then rerun the benchmark. See+<https://hackage.haskell.org/package/tasty-bench> package, for instructions on+comparing benchmarks, using patterns to run a single benchmark or log results to+a file. Furthermore, we provide a few utility functions to ease the details in+benchmarking standalone z3 programs and sbv programs in Utils.SBVBenchFramework.+`cabal build SBVBench; ./SBVBench --match=pattern -- 'NQueens'`. Note that+comparisons with benchmarks run on different machines will be spurious so use+your best judgment.+-} main :: IO () main = do-  -- generate the benchmark file name-  -- let f = benchResultsFile "<your-test-name-here>"+  -- timeout is set to 2 minutes+  let timeout    = localOption (mkTimeout 120000000)+      opts       = [timeout]+      setOptions :: Benchmark -> Benchmark+      setOptions = foldr (.) id opts -  -- Your code on interest here-  putStrLn "running"-  counts+  -- run the benchmarks+  defaultMain+    $ setOptions <$> [ puzzles+                     , bitPrecise+                     , queries+                     , weakestPreconditions+                     , optimizations+                     , uninterpreted+                     , proofTools+                     -- , codeGeneration :NOTE code generation takes too much time and memory+                     -- crypto :NOTE crypto also is too expensive+                     , misc+                     , lists+                     , strings+                     , transformers+                     ] -  -- satisfying the type system-  -- return ()+-- | Benchmarks for 'Documentation.SBV.Examples.Puzzles'. Each benchmark file+-- defines a 'benchmarks' function which returns a+-- 'BenchSuite.Bench.Bench.Runner'. We want to allow benchmarks to be defined as+-- closely as possible to the problems being solved. But for practical reasons+-- we may desire to prevent benchmarking 'Data.SBV.allSat' calls because they+-- could timeout. Thus by using 'BenchSuite.Bench.Bench.Runner' we can define+-- the benchmark mirroring the logic of the symbolic program and change solver+-- details _without_ redefining the benchmark, as I have done below by+-- converting all examples to use 'Data.SBV.satWith'. For benchmarks which do+-- not need to run with different solver configurations, such as queries we run+-- with `BenchSuite.Bench.Bench.Runner.runIO`++--------------------------- Puzzles ---------------------------------------------+puzzleBenchmarks :: [Runner]+puzzleBenchmarks = [ BenchSuite.Puzzles.Coins.benchmarks+                   -- disable Counts for now, there is some issue with the counts function+                   -- in a repl it works fine, when compiled it does not terminate+                   -- , BenchSuite.Puzzles.Counts.benchmarks+                   , BenchSuite.Puzzles.Birthday.benchmarks+                   , BenchSuite.Puzzles.DogCatMouse.benchmarks+                   -- expensive+                   -- , BenchSuite.Puzzles.Euler185.benchmarks+                   , BenchSuite.Puzzles.Garden.benchmarks+                   , BenchSuite.Puzzles.LadyAndTigers.benchmarks+                   , BenchSuite.Puzzles.SendMoreMoney.benchmarks+                   , BenchSuite.Puzzles.NQueens.benchmarks+                   , BenchSuite.Puzzles.MagicSquare.benchmarks+                   , BenchSuite.Puzzles.Sudoku.benchmarks+                   -- TODO: sbv finishes cnt3 in 100s but z3 does so in 83 ms,+                   -- probably an issue with z3 here ,+                   -- BenchSuite.Puzzles.U2Bridge.benchmarks+                   ]++puzzles :: Benchmark+puzzles = bgroup "Puzzles" $ runBenchmark <$> puzzleBenchmarks+++--------------------------- BitPrecise ------------------------------------------+bitPreciseBenchmarks :: [Runner]+bitPreciseBenchmarks = [ BenchSuite.BitPrecise.BitTricks.benchmarks+                       -- These benchmarks blow the stack :TODO fix them+                       -- , BenchSuite.BitPrecise.BrokenSearch.benchmarks+                       -- , BenchSuite.BitPrecise.Legato.benchmarks+                       -- , BenchSuite.BitPrecise.MergeSort.benchmarks+                       , BenchSuite.BitPrecise.MultMask.benchmarks+                       -- expensive+                       -- , BenchSuite.BitPrecise.PrefixSum.benchmarks+                       ]++bitPrecise :: Benchmark+bitPrecise = bgroup "BitPrecise" $ runBenchmark <$> bitPreciseBenchmarks+++--------------------------- Query -----------------------------------------------+queryBenchmarks :: [Runner]+queryBenchmarks = [ BenchSuite.Queries.AllSat.benchmarks+                  , BenchSuite.Queries.CaseSplit.benchmarks+                  -- The concurrency demo has STM blocking when benchmarking+                  -- , BenchSuite.Queries.Concurrency.benchmarks+                  , BenchSuite.Queries.Enums.benchmarks+                  , BenchSuite.Queries.FourFours.benchmarks+                  , BenchSuite.Queries.GuessNumber.benchmarks+                  , BenchSuite.Queries.Interpolants.benchmarks+                  , BenchSuite.Queries.UnsatCore.benchmarks+                  ]++queries :: Benchmark+queries = bgroup "Queries" $ runBenchmark <$> queryBenchmarks+++--------------------------- WeakestPreconditions --------------------------------+weakestPreconditionBenchmarks :: [Runner]+weakestPreconditionBenchmarks =+  [ BenchSuite.WeakestPreconditions.Append.benchmarks+  , BenchSuite.WeakestPreconditions.Basics.benchmarks+  , BenchSuite.WeakestPreconditions.Fib.benchmarks+  , BenchSuite.WeakestPreconditions.GCD.benchmarks+  , BenchSuite.WeakestPreconditions.IntDiv.benchmarks+  , BenchSuite.WeakestPreconditions.IntSqrt.benchmarks+  , BenchSuite.WeakestPreconditions.Length.benchmarks+  , BenchSuite.WeakestPreconditions.Sum.benchmarks+  ]++weakestPreconditions :: Benchmark+weakestPreconditions = bgroup "WeakestPreconditions" $+  runBenchmark <$> weakestPreconditionBenchmarks+++--------------------------- Optimizations ---------------------------------------+optimizationBenchmarks :: [Runner]+optimizationBenchmarks = [ BenchSuite.Optimization.Enumerate.benchmarks+                         , BenchSuite.Optimization.ExtField.benchmarks+                         , BenchSuite.Optimization.LinearOpt.benchmarks+                         , BenchSuite.Optimization.Production.benchmarks+                         , BenchSuite.Optimization.VM.benchmarks+                         ]++optimizations :: Benchmark+optimizations = bgroup "Optimizations" $ runBenchmark <$> optimizationBenchmarks+++--------------------------- Uninterpreted ---------------------------------------+uninterpretedBenchmarks :: [Runner]+uninterpretedBenchmarks = [ BenchSuite.Uninterpreted.AUF.benchmarks+                          , BenchSuite.Uninterpreted.Deduce.benchmarks+                          , BenchSuite.Uninterpreted.Function.benchmarks+                          , BenchSuite.Uninterpreted.Multiply.benchmarks+                          , BenchSuite.Uninterpreted.Shannon.benchmarks+                          , BenchSuite.Uninterpreted.Sort.benchmarks+                          , BenchSuite.Uninterpreted.UISortAllSat.benchmarks+                          ]++uninterpreted :: Benchmark+uninterpreted = bgroup "Uninterpreted" $ runBenchmark <$> uninterpretedBenchmarks+++--------------------------- ProofTools -----------------------------------------+proofToolBenchmarks :: [Runner]+proofToolBenchmarks = [ BenchSuite.ProofTools.BMC.benchmarks+                      , BenchSuite.ProofTools.Fibonacci.benchmarks+                      , BenchSuite.ProofTools.Strengthen.benchmarks+                      , BenchSuite.ProofTools.Sum.benchmarks+                      ]++proofTools :: Benchmark+proofTools = bgroup "ProofTools" $ runBenchmark <$> proofToolBenchmarks+++--------------------------- Code Generation -------------------------------------+codeGenerationBenchmarks :: [Runner]+codeGenerationBenchmarks = [ BenchSuite.CodeGeneration.AddSub.benchmarks+                           , BenchSuite.CodeGeneration.CRC_USB5.benchmarks+                           , BenchSuite.CodeGeneration.Fibonacci.benchmarks+                           , BenchSuite.CodeGeneration.GCD.benchmarks+                           , BenchSuite.CodeGeneration.PopulationCount.benchmarks+                           , BenchSuite.CodeGeneration.Uninterpreted.benchmarks+                           ]++codeGeneration :: Benchmark+codeGeneration = bgroup "CodeGeneration" $+                 runBenchmark <$> codeGenerationBenchmarks+++--------------------------- Crypto ----------------------------------------------+cryptoBenchmarks :: [Runner]+cryptoBenchmarks = [ BenchSuite.Crypto.AES.benchmarks+                   , BenchSuite.Crypto.RC4.benchmarks+                   , BenchSuite.Crypto.SHA.benchmarks+                   ]++crypto :: Benchmark+crypto = bgroup "Crypto" $ runBenchmark <$> cryptoBenchmarks+++--------------------------- Miscellaneous ---------------------------------------+miscBenchmarks :: [Runner]+miscBenchmarks = [ BenchSuite.Misc.Auxiliary.benchmarks+                 , BenchSuite.Misc.Enumerate.benchmarks+                 -- expensive+                 -- , BenchSuite.Misc.Floating.benchmarks+                 , BenchSuite.Misc.ModelExtract.benchmarks+                 , BenchSuite.Misc.Newtypes.benchmarks+                 , BenchSuite.Misc.NoDiv0.benchmarks+                 -- killed by OS, TODO: Investigate+                 -- , BenchSuite.Misc.Polynomials.benchmarks+                 , BenchSuite.Misc.SetAlgebra.benchmarks+                 , BenchSuite.Misc.SoftConstrain.benchmarks+                 , BenchSuite.Misc.Tuple.benchmarks+                 ]++misc :: Benchmark+misc = bgroup "Miscellaneous" $ runBenchmark <$> miscBenchmarks+++--------------------------- Lists -----------------------------------------------+listBenchmarks :: [Runner]+listBenchmarks = [ BenchSuite.Lists.BoundedMutex.benchmarks+                 , BenchSuite.Lists.Fibonacci.benchmarks+                 , BenchSuite.Lists.Nested.benchmarks+                 ]++lists :: Benchmark+lists = bgroup "Lists" $ runBenchmark <$> listBenchmarks+++--------------------------- Strings ---------------------------------------------+stringBenchmarks :: [Runner]+stringBenchmarks = [ BenchSuite.Strings.RegexCrossword.benchmarks+                   , BenchSuite.Strings.SQLInjection.benchmarks+                   ]++strings :: Benchmark+strings = bgroup "Strings" $ runBenchmark <$> stringBenchmarks+++--------------------------- Existentials ----------------------------------------+existentialBenchmarks :: [Runner]+existentialBenchmarks = [ BenchSuite.Existentials.CRCPolynomial.benchmarks+                        , BenchSuite.Existentials.Diophantine.benchmarks+                        ]++existentials :: Benchmark+existentials = bgroup "Existentials" $ runBenchmark <$> existentialBenchmarks+++--------------------------- Transformers ----------------------------------------+transformerBenchmarks :: [Runner]+transformerBenchmarks = [ BenchSuite.Transformers.SymbolicEval.benchmarks+                        ]++transformers :: Benchmark+transformers = bgroup "Transformers" $ runBenchmark <$> transformerBenchmarks
− SBVBenchSuite/SBVBenchmark.hs 
@@ -1,394 +0,0 @@--------------------------------------------------------------------------------- |--- Module    : SBVBench--- Copyright : (c) Jeffrey Young---                 Levent Erkok--- License   : BSD3--- Maintainer: erkokl@gmail.com--- Stability : experimental------ Entry point to benchmark SBV. We define this as a separate cabal target so--- that performance regressions can continue to occur as other fine-tuning--- happens in parallel--------------------------------------------------------------------------------module Main where--import qualified Gauge.Main as G-import           Gauge.Main.Options (defaultConfig, Config(..))--import           Utils.SBVBenchFramework--import           BenchSuite.Bench.Bench---- Puzzles-import qualified BenchSuite.Puzzles.Birthday-import qualified BenchSuite.Puzzles.Coins--- import qualified BenchSuite.Puzzles.Counts -- see comment below-import qualified BenchSuite.Puzzles.DogCatMouse--- import qualified BenchSuite.Puzzles.Euler185-import qualified BenchSuite.Puzzles.Garden-import qualified BenchSuite.Puzzles.LadyAndTigers-import qualified BenchSuite.Puzzles.MagicSquare-import qualified BenchSuite.Puzzles.NQueens-import qualified BenchSuite.Puzzles.SendMoreMoney-import qualified BenchSuite.Puzzles.Sudoku--- import qualified BenchSuite.Puzzles.U2Bridge---- BitPrecise-import qualified BenchSuite.BitPrecise.BitTricks--- import qualified BenchSuite.BitPrecise.BrokenSearch--- import qualified BenchSuite.BitPrecise.Legato--- import qualified BenchSuite.BitPrecise.MergeSort-import qualified BenchSuite.BitPrecise.MultMask--- import qualified BenchSuite.BitPrecise.PrefixSum---- Queries-import qualified BenchSuite.Queries.AllSat-import qualified BenchSuite.Queries.CaseSplit--- import qualified BenchSuite.Queries.Concurrency-import qualified BenchSuite.Queries.Enums-import qualified BenchSuite.Queries.FourFours-import qualified BenchSuite.Queries.GuessNumber-import qualified BenchSuite.Queries.Interpolants-import qualified BenchSuite.Queries.UnsatCore---- Weakest Preconditions-import qualified BenchSuite.WeakestPreconditions.Append-import qualified BenchSuite.WeakestPreconditions.Basics-import qualified BenchSuite.WeakestPreconditions.Fib-import qualified BenchSuite.WeakestPreconditions.GCD-import qualified BenchSuite.WeakestPreconditions.IntDiv-import qualified BenchSuite.WeakestPreconditions.IntSqrt-import qualified BenchSuite.WeakestPreconditions.Length-import qualified BenchSuite.WeakestPreconditions.Sum---- Optimization-import qualified BenchSuite.Optimization.Enumerate-import qualified BenchSuite.Optimization.ExtField-import qualified BenchSuite.Optimization.LinearOpt-import qualified BenchSuite.Optimization.Production-import qualified BenchSuite.Optimization.VM---- Uninterpreted-import qualified BenchSuite.Uninterpreted.AUF-import qualified BenchSuite.Uninterpreted.Deduce-import qualified BenchSuite.Uninterpreted.Function-import qualified BenchSuite.Uninterpreted.Multiply-import qualified BenchSuite.Uninterpreted.Shannon-import qualified BenchSuite.Uninterpreted.Sort-import qualified BenchSuite.Uninterpreted.UISortAllSat---- Proof Tools-import qualified BenchSuite.ProofTools.BMC-import qualified BenchSuite.ProofTools.Fibonacci-import qualified BenchSuite.ProofTools.Strengthen-import qualified BenchSuite.ProofTools.Sum---- Code Generation-import qualified BenchSuite.CodeGeneration.AddSub-import qualified BenchSuite.CodeGeneration.CRC_USB5-import qualified BenchSuite.CodeGeneration.Fibonacci-import qualified BenchSuite.CodeGeneration.GCD-import qualified BenchSuite.CodeGeneration.PopulationCount-import qualified BenchSuite.CodeGeneration.Uninterpreted---- Crypto-import qualified BenchSuite.Crypto.AES-import qualified BenchSuite.Crypto.RC4-import qualified BenchSuite.Crypto.SHA---- Miscellaneous-import qualified BenchSuite.Misc.Auxiliary-import qualified BenchSuite.Misc.Enumerate--- import qualified BenchSuite.Misc.Floating-import qualified BenchSuite.Misc.ModelExtract-import qualified BenchSuite.Misc.Newtypes-import qualified BenchSuite.Misc.NoDiv0--- import qualified BenchSuite.Misc.Polynomials-import qualified BenchSuite.Misc.SetAlgebra-import qualified BenchSuite.Misc.SoftConstrain-import qualified BenchSuite.Misc.Tuple---- Lists-import qualified BenchSuite.Lists.BoundedMutex-import qualified BenchSuite.Lists.Fibonacci-import qualified BenchSuite.Lists.Nested---- Strings-import qualified BenchSuite.Strings.RegexCrossword-import qualified BenchSuite.Strings.SQLInjection---- Existentials-import qualified BenchSuite.Existentials.CRCPolynomial-import qualified BenchSuite.Existentials.Diophantine---- Transformers-import qualified BenchSuite.Transformers.SymbolicEval---- | Custom config to limit benchmarks to 2 minutes of runtime. This is required--- because we can easily generate benchmarks that take a lot of wall time to--- solve, especially with 'Data.SBV.allSatWith' calls-benchConfig :: Config-benchConfig = defaultConfig { timeLimit = Just 120.00 }--{--To benchmark sbv we require two use cases: For continuous integration we want a-snapshot of all benchmarks at a given point in time and we want to be able to-compare benchmarks over time for performance tuning. For this module we default-to the continuous integration flow, thus 'cabal bench' this will get a timestamp-for the file, e.g., '2020-06-27-15:54:05.447753608-UTC.csv', run the benchmarks-and output the statistics to that file in 'sbv/BenchSuite/BenchFiles\/'. The-workflow for fine grained performance analysis is to run a benchmark, make your-changes, then rerun the benchmark. We analyze these results using the-<http://hackage.haskell.org/package/bench-show-0.3.1 bench-show> package, we-provide a few wrappers to ease the details in Utils.SBVBenchFramework.hs. So to-generate a report call compareBenchmarks <file-before-change>-<file-after-change> for example: > compareBenchmarks-"SBVBenchSuite/BenchResults/2020-07-27-17:04:04.261168259-UTC.csv"-"SBVBenchSuite/BenchResults/2020-07-27-17:23:53.048061816-UTC.csv". If you have-the results already aggregated to a single file then use the ticked versions,-e.g., compareBenchmarks'. To only run one or a few benchmarks we use the-'--match' command from the <https://hackage.haskell.org/package/gauge-0.2.5-gauge> library. For example to run only NQueens you would do the following:-`cabal build SBVBench; ./SBVBench --match=pattern -- 'NQueens'`. Note that-comparisons with benchmarks run on different machines will be spurious so use-your best judgment.--}-main :: IO ()-main = do-  -- generate the benchmark file name-  f <- benchResultsFile <$> timeStamp--  -- run the benchmarks-  G.defaultMainWith benchConfig {csvFile = Just f} $-       [ puzzles-       , bitPrecise-       -- , queries :TODO queries are not running with overHead-       , weakestPreconditions-       , optimizations-       , uninterpreted-       , proofTools-       -- , codeGeneration :NOTE code generation takes too much time and memory-       -- crypto :NOTE crypto also is too expensive-       , misc-       , lists-       , strings-       , transformers-       ]---- | Benchmarks for 'Documentation.SBV.Examples.Puzzles'. Each benchmark file--- defines a 'benchmarks' function which returns a--- 'BenchSuite.Bench.Bench.Runner'. We want to allow benchmarks to be defined as--- closely as possible to the problems being solved. But for practical reasons--- we may desire to prevent benchmarking 'Data.SBV.allSat' calls because they--- could timeout. Thus by using 'BenchSuite.Bench.Bench.Runner' we can define--- the benchmark mirroring the logic of the symbolic program and change solver--- details _without_ redefining the benchmark, as I have done below by--- converting all examples to use 'Data.SBV.satWith'. For benchmarks which do--- not need to run with different solver configurations, such as queries we run--- with `BenchSuite.Bench.Bench.Runner.runIO`----------------------------- Puzzles ----------------------------------------------puzzleBenchmarks :: [Runner]-puzzleBenchmarks = [ BenchSuite.Puzzles.Coins.benchmarks-                   -- disable Counts for now, there is some issue with the counts function-                   -- in a repl it works fine, when compiled it does not terminate- --                , BenchSuite.Puzzles.Counts.benchmarks-                   , BenchSuite.Puzzles.Birthday.benchmarks-                   , BenchSuite.Puzzles.DogCatMouse.benchmarks-                   -- expensive-                   -- , BenchSuite.Puzzles.Euler185.benchmarks-                   , BenchSuite.Puzzles.Garden.benchmarks-                   , BenchSuite.Puzzles.LadyAndTigers.benchmarks-                   , BenchSuite.Puzzles.SendMoreMoney.benchmarks-                   , BenchSuite.Puzzles.NQueens.benchmarks-                   , BenchSuite.Puzzles.MagicSquare.benchmarks-                   , BenchSuite.Puzzles.Sudoku.benchmarks-                   -- TODO: sbv finishes cnt3 in 100s but z3 does so in 83 ms,-                   -- probably an issue with z3 here ,-                   -- BenchSuite.Puzzles.U2Bridge.benchmarks-                   ]---- | We call `runOverheadBenchmark` run the benchmarks with both sbv and z3--- native on the same program. To construct a benchmark for only sbv one would--- call `runBenchmark`-puzzles :: Benchmark-puzzles = bgroup "Puzzles" $ runOverheadBenchmark <$> puzzleBenchmarks------------------------------ BitPrecise -------------------------------------------bitPreciseBenchmarks :: [Runner]-bitPreciseBenchmarks = [ BenchSuite.BitPrecise.BitTricks.benchmarks-                       -- These benchmarks blow the stack :TODO fix them-                       -- , BenchSuite.BitPrecise.BrokenSearch.benchmarks-                       -- , BenchSuite.BitPrecise.Legato.benchmarks-                       -- , BenchSuite.BitPrecise.MergeSort.benchmarks-                       , BenchSuite.BitPrecise.MultMask.benchmarks-                       -- expensive-                       -- , BenchSuite.BitPrecise.PrefixSum.benchmarks-                       ]--bitPrecise :: Benchmark-bitPrecise = bgroup "BitPrecise" $ runOverheadBenchmark <$> bitPreciseBenchmarks------------------------------ Query ------------------------------------------------queryBenchmarks :: [Runner]-queryBenchmarks = [ BenchSuite.Queries.AllSat.benchmarks-                  , BenchSuite.Queries.CaseSplit.benchmarks-                  -- The concurrency demo has STM blocking when benchmarking-                  -- , BenchSuite.Queries.Concurrency.benchmarks-                  , BenchSuite.Queries.Enums.benchmarks-                  , BenchSuite.Queries.FourFours.benchmarks-                  , BenchSuite.Queries.GuessNumber.benchmarks-                  , BenchSuite.Queries.Interpolants.benchmarks-                  , BenchSuite.Queries.UnsatCore.benchmarks-                  ]--queries :: Benchmark-queries = bgroup "Queries" $ runOverheadBenchmark <$> queryBenchmarks------------------------------ WeakestPreconditions ---------------------------------weakestPreconditionBenchmarks :: [Runner]-weakestPreconditionBenchmarks =-  [ BenchSuite.WeakestPreconditions.Append.benchmarks-  , BenchSuite.WeakestPreconditions.Basics.benchmarks-  , BenchSuite.WeakestPreconditions.Fib.benchmarks-  , BenchSuite.WeakestPreconditions.GCD.benchmarks-  , BenchSuite.WeakestPreconditions.IntDiv.benchmarks-  , BenchSuite.WeakestPreconditions.IntSqrt.benchmarks-  , BenchSuite.WeakestPreconditions.Length.benchmarks-  , BenchSuite.WeakestPreconditions.Sum.benchmarks-  ]--weakestPreconditions :: Benchmark-weakestPreconditions = bgroup "WeakestPreconditions" $-  runOverheadBenchmark <$> weakestPreconditionBenchmarks------------------------------ Optimizations ----------------------------------------optimizationBenchmarks :: [Runner]-optimizationBenchmarks = [ BenchSuite.Optimization.Enumerate.benchmarks-                         , BenchSuite.Optimization.ExtField.benchmarks-                         , BenchSuite.Optimization.LinearOpt.benchmarks-                         , BenchSuite.Optimization.Production.benchmarks-                         , BenchSuite.Optimization.VM.benchmarks-                         ]--optimizations :: Benchmark-optimizations = bgroup "Optimizations" $ runOverheadBenchmark <$> optimizationBenchmarks------------------------------ Uninterpreted ----------------------------------------uninterpretedBenchmarks :: [Runner]-uninterpretedBenchmarks = [ BenchSuite.Uninterpreted.AUF.benchmarks-                          , BenchSuite.Uninterpreted.Deduce.benchmarks-                          , BenchSuite.Uninterpreted.Function.benchmarks-                          , BenchSuite.Uninterpreted.Multiply.benchmarks-                          , BenchSuite.Uninterpreted.Shannon.benchmarks-                          , BenchSuite.Uninterpreted.Sort.benchmarks-                          , BenchSuite.Uninterpreted.UISortAllSat.benchmarks-                          ]--uninterpreted :: Benchmark-uninterpreted = bgroup "Uninterpreted" $ runOverheadBenchmark <$> uninterpretedBenchmarks------------------------------ ProofTools ------------------------------------------proofToolBenchmarks :: [Runner]-proofToolBenchmarks = [ BenchSuite.ProofTools.BMC.benchmarks-                      , BenchSuite.ProofTools.Fibonacci.benchmarks-                      , BenchSuite.ProofTools.Strengthen.benchmarks-                      , BenchSuite.ProofTools.Sum.benchmarks-                      ]--proofTools :: Benchmark-proofTools = bgroup "ProofTools" $ runOverheadBenchmark <$> proofToolBenchmarks------------------------------ Code Generation --------------------------------------codeGenerationBenchmarks :: [Runner]-codeGenerationBenchmarks = [ BenchSuite.CodeGeneration.AddSub.benchmarks-                           , BenchSuite.CodeGeneration.CRC_USB5.benchmarks-                           , BenchSuite.CodeGeneration.Fibonacci.benchmarks-                           , BenchSuite.CodeGeneration.GCD.benchmarks-                           , BenchSuite.CodeGeneration.PopulationCount.benchmarks-                           , BenchSuite.CodeGeneration.Uninterpreted.benchmarks-                           ]--codeGeneration :: Benchmark-codeGeneration = bgroup "CodeGeneration" $-                 runOverheadBenchmark <$> codeGenerationBenchmarks------------------------------ Crypto -----------------------------------------------cryptoBenchmarks :: [Runner]-cryptoBenchmarks = [ BenchSuite.Crypto.AES.benchmarks-                   , BenchSuite.Crypto.RC4.benchmarks-                   , BenchSuite.Crypto.SHA.benchmarks-                   ]--crypto :: Benchmark-crypto = bgroup "Crypto" $ runOverheadBenchmark <$> cryptoBenchmarks------------------------------ Miscellaneous ----------------------------------------miscBenchmarks :: [Runner]-miscBenchmarks = [ BenchSuite.Misc.Auxiliary.benchmarks-                 , BenchSuite.Misc.Enumerate.benchmarks-                 -- expensive-                 -- , BenchSuite.Misc.Floating.benchmarks-                 , BenchSuite.Misc.ModelExtract.benchmarks-                 , BenchSuite.Misc.Newtypes.benchmarks-                 , BenchSuite.Misc.NoDiv0.benchmarks-                 -- killed by OS, TODO: Investigate-                 -- , BenchSuite.Misc.Polynomials.benchmarks-                 , BenchSuite.Misc.SetAlgebra.benchmarks-                 , BenchSuite.Misc.SoftConstrain.benchmarks-                 , BenchSuite.Misc.Tuple.benchmarks-                 ]--misc :: Benchmark-misc = bgroup "Miscellaneous" $ runOverheadBenchmark <$> miscBenchmarks------------------------------ Lists ------------------------------------------------listBenchmarks :: [Runner]-listBenchmarks = [ BenchSuite.Lists.BoundedMutex.benchmarks-                 , BenchSuite.Lists.Fibonacci.benchmarks-                 , BenchSuite.Lists.Nested.benchmarks-                 ]--lists :: Benchmark-lists = bgroup "Lists" $ runOverheadBenchmark <$> listBenchmarks------------------------------ Strings ----------------------------------------------stringBenchmarks :: [Runner]-stringBenchmarks = [ BenchSuite.Strings.RegexCrossword.benchmarks-                   , BenchSuite.Strings.SQLInjection.benchmarks-                   ]--strings :: Benchmark-strings = bgroup "Strings" $ runOverheadBenchmark <$> stringBenchmarks------------------------------ Existentials -----------------------------------------existentialBenchmarks :: [Runner]-existentialBenchmarks = [ BenchSuite.Existentials.CRCPolynomial.benchmarks-                        , BenchSuite.Existentials.Diophantine.benchmarks-                        ]--existentials :: Benchmark-existentials = bgroup "Existentials" $ runOverheadBenchmark <$> existentialBenchmarks------------------------------ Transformers -----------------------------------------transformerBenchmarks :: [Runner]-transformerBenchmarks = [ BenchSuite.Transformers.SymbolicEval.benchmarks-                        ]--transformers :: Benchmark-transformers = bgroup "Transformers" $ runOverheadBenchmark <$> transformerBenchmarks
SBVBenchSuite/Utils/SBVBenchFramework.hs view
@@ -10,29 +10,19 @@ -- Various goodies for benchmarking SBV ----------------------------------------------------------------------------- -{-# LANGUAGE LambdaCase #-} {-# LANGUAGE OverloadedStrings #-}  module Utils.SBVBenchFramework   ( mkExecString   , mkFileName-  , Benchmark-  , bgroup   , module Data.SBV   , timeStamp   , getDate   , dateStamp   , benchResultsFile-  , compareBenchmarks-  , compareBenchmarks'-  , compareBenchmarksOvHd-  , compareBenchmarksWith-  , compareBenchmarksWith'   , classifier   , overheadClassifier   , filterOverhead-  , regressionConf-  , overheadConf   ) where  import qualified Data.List      as L@@ -40,16 +30,9 @@ import           System.Random import           Data.Char (isSpace) import           System.FilePath ((</>), (<.>))-import           System.FilePath.Posix (takeBaseName)-import           System.IO (appendFile, readFile)-import           System.Process (callCommand)-import           Data.Ord (comparing) import           Data.Time.Clock import           Data.Time.Calendar -import           Gauge.Main (Benchmark, bgroup)-import qualified BenchShow as BS hiding (verbose)- import           Data.SBV  -- | make the string to call executable from the command line. All the heavy@@ -92,88 +75,28 @@ benchResultsFile :: FilePath -> FilePath benchResultsFile nm = "SBVBenchSuite" </> "BenchResults" </> nm <.> "csv" --- | Run bench-show comparisons given an old-file, a newfile, and a config.--- Bench show expects comparisons to be in a single file so we construct a file--- by appending the input files and then remove it after the comparison.--- bench-show differentiates the runs by a header generated from either @gauge@--- or @criterion@. See <http://hackage.haskell.org/package/bench-show-0.3.1 bench-show>--- for more details.-compareBenchmarksWith :: BS.Config -> FilePath -> FilePath -> IO ()-compareBenchmarksWith conf old new = do-  -- make the file name-  let fname = benchResultsFile $ takeBaseName old ++ "_vs_" ++ takeBaseName new-  -- this is lazy IO !!!-  readFile old >>= appendFile fname-  readFile new >>= appendFile fname-  -- run the report-  BS.report fname Nothing conf-  -- remove the file, this will likely fail on Windows-  callCommand $ "rm " ++ fname---- | A simple wrapper for a single file case-compareBenchmarksWith' :: BS.Config -> FilePath -> IO ()-compareBenchmarksWith' c fp = BS.report fp Nothing c--compareBenchmarks' :: FilePath -> IO ()-compareBenchmarks' = compareBenchmarksWith' regressionConf--compareBenchmarks :: FilePath -> FilePath -> IO ()-compareBenchmarks = compareBenchmarksWith regressionConf---compareBenchmarksOvHd :: FilePath -> FilePath -> IO ()-compareBenchmarksOvHd = compareBenchmarksWith overheadConf---regressionConf :: BS.Config-regressionConf = BS.defaultConfig { BS.presentation = BS.Groups BS.PercentDiff -- report percent difference-                                  , BS.selectBenchmarks = \f ->                -- sort from Improvement - Degradation-                                                            map fst-                                                            $ L.sortBy (comparing snd)-                                                            $ either error id-                                                            $ f (BS.ColumnIndex 1) Nothing-                                  }---overheadConf :: BS.Config-overheadConf = BS.defaultConfig { BS.classifyBenchmark = overheadClassifier '/'  -- separate groups assuming overhead results-                                , BS.presentation = BS.Groups BS.PercentDiff-                                , BS.selectBenchmarks = \f ->-                                                          map fst-                                                          $ L.sortBy (comparing snd)-                                                          $ either error id-                                                          $ f (BS.ColumnIndex 1) Nothing-                                }-- -- | The classifier takes a line of text and chunks it into (group-name, -- benchmark-name), for example:--- >>> classifier '/' "Puzzles//Coins"--- Just ("Puzzles/","Coins")--- classifier :: Char -> String -> Maybe (String, String)-classifier e nm = Just $ last $ fmap (\(a,b) -> (a, tail b)) chunks+classifier e nm = Just $ last chunks   where     is :: [Int]     is = L.elemIndices e nm -    chunks = fmap (flip L.splitAt nm) is+    chunks = [(a, tail b) | (a, b) <- fmap (`L.splitAt` nm) is]  -- | We live with some code duplication due to the way overhead benchmarks apply -- the "standalone" and "sbv" labels. By abstracting for overhead benchmarks -- these labels will be appended to the description string. This is counter to -- the assumptions of the bench-show package, thus we define a specialty -- classifier to handle the overhead case--- >>> overheadClassifier '/' "Puzzles//DogCatMouse/standalone"--- Just ("standalone","Puzzles//DogCatMouse")--- overheadClassifier :: Char -> String -> Maybe (String, String) overheadClassifier e nm = Just $ last $ fmap (\(a,b) -> (tail b, a)) chunks   where     is :: [Int]     is = L.elemIndices e nm -    chunks = fmap (flip L.splitAt nm) is+    chunks = fmap (`L.splitAt` nm) is  -- | a helper function to remove benchmarks where the over head benchmark -- doesn't work or failed for some reason. This will write a filtered version@@ -186,6 +109,6 @@                          -- overhead by '/' an overhead run will have >3 splits,                          -- but a normal benchmark will only have two from '//'                          let filteredContent   = filter ((>=3) . length . L.elemIndices e) file-                             filteredFilePath  = (fp ++ "_filtered")+                             filteredFilePath  = fp ++ "_filtered"                          writeFile  filteredFilePath (concat $ header:filteredContent)                          return filteredFilePath
SBVTestSuite/GoldFiles/allSat7.gold view
@@ -1196,33256 +1196,33256 @@ [SEND] (get-value (s1)) [RECV] ((s1 6)) [SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 90-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 91-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 92-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 93-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 94-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 95-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 96-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 97-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 98-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 99-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 100-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 101-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s63)-[GOOD] (define-fun s78 () Bool (= s1 s26))-[GOOD] (assert s78)-Fast allSat, Looking for solution 101-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 102-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 103-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 104-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 105-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 106-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 107-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 108-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 109-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 110-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 111-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 112-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 113-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s64)-[GOOD] (define-fun s79 () Bool (= s1 s28))-[GOOD] (assert s79)-Fast allSat, Looking for solution 113-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 114-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 115-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 116-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 117-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 118-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 119-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 120-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 121-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 122-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 123-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 124-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 125-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s65)-[GOOD] (define-fun s80 () Bool (= s1 s30))-[GOOD] (assert s80)-Fast allSat, Looking for solution 125-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 126-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 127-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 128-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 129-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 130-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 131-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 132-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 133-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 134-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 135-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 136-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 137-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s66)-[GOOD] (define-fun s81 () Bool (= s1 s32))-[GOOD] (assert s81)-Fast allSat, Looking for solution 137-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 138-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 139-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 140-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 141-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 142-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 143-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 144-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 145-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 146-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 147-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 148-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 149-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s67)-[GOOD] (define-fun s82 () Bool (= s1 s34))-[GOOD] (assert s82)-Fast allSat, Looking for solution 149-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 150-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 151-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 152-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 153-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 154-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 155-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 156-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 157-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 158-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 159-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 160-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 161-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s68)-[GOOD] (define-fun s83 () Bool (= s1 s36))-[GOOD] (assert s83)-Fast allSat, Looking for solution 161-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 162-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 163-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 164-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 165-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 166-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 167-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 168-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 169-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 170-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 171-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 172-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 173-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s69)-[GOOD] (define-fun s84 () Bool (= s1 s38))-[GOOD] (assert s84)-Fast allSat, Looking for solution 173-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 174-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 175-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 176-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 177-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 178-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 179-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 180-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 181-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 182-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 183-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 184-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 185-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s70)-[GOOD] (assert s44)-[GOOD] (define-fun s85 () Bool (= s1 s40))-[GOOD] (assert s85)-Fast allSat, Looking for solution 185-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 186-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 187-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 188-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 189-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 190-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 191-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 192-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 193-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 194-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 195-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 196-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 197-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (define-fun s86 () Bool (distinct s1 s5))-[GOOD] (assert s86)-[GOOD] (define-fun s87 () Bool (= s0 s40))-[GOOD] (assert s87)-Fast allSat, Looking for solution 197-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s46)-Fast allSat, Looking for solution 198-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s47)-Fast allSat, Looking for solution 199-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s48)-Fast allSat, Looking for solution 200-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s49)-Fast allSat, Looking for solution 201-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s50)-Fast allSat, Looking for solution 202-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s51)-Fast allSat, Looking for solution 203-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s52)-Fast allSat, Looking for solution 204-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s53)-Fast allSat, Looking for solution 205-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s54)-Fast allSat, Looking for solution 206-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s55)-Fast allSat, Looking for solution 207-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s56)-Fast allSat, Looking for solution 208-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s57)-Fast allSat, Looking for solution 209-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s45)-Fast allSat, Looking for solution 210-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (define-fun s88 () Bool (distinct s2 s5))-[GOOD] (assert s88)-[GOOD] (assert s84)-Fast allSat, Looking for solution 210-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 211-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 212-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 213-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 214-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 215-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 216-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 217-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 218-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 219-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 220-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 221-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 222-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s70)-[GOOD] (assert s59)-Fast allSat, Looking for solution 222-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 223-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 224-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 225-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 226-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 227-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 228-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 229-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 230-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 231-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 232-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 233-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 234-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s70)-[GOOD] (assert s73)-Fast allSat, Looking for solution 234-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 235-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 236-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 237-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 238-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 239-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 240-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 241-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 242-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 243-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 244-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 245-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 246-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s70)-[GOOD] (assert s74)-Fast allSat, Looking for solution 246-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 247-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 248-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 249-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 250-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 251-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 252-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 253-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 254-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 255-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 256-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 257-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 258-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s70)-[GOOD] (assert s75)-Fast allSat, Looking for solution 258-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 259-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 260-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 261-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 262-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 263-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 264-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 265-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 266-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 267-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 268-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 269-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 270-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s70)-[GOOD] (assert s76)-Fast allSat, Looking for solution 270-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 271-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 272-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 273-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 274-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 275-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 276-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 277-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 278-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 279-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 280-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 281-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 282-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s70)-[GOOD] (assert s77)-Fast allSat, Looking for solution 282-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 283-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 284-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 285-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 286-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 287-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 288-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 289-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 290-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 291-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 292-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 293-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 294-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s70)-[GOOD] (assert s78)-Fast allSat, Looking for solution 294-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 295-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 296-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 297-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 298-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 299-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 300-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 301-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 302-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 303-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 304-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 305-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 306-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s70)-[GOOD] (assert s79)-Fast allSat, Looking for solution 306-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 307-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 308-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 309-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 310-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 311-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 312-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 313-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 314-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 315-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 316-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 317-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 318-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s70)-[GOOD] (assert s80)-Fast allSat, Looking for solution 318-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 319-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 320-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 321-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 322-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 323-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 324-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 325-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 326-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 327-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 328-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 329-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 330-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s70)-[GOOD] (assert s81)-Fast allSat, Looking for solution 330-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 331-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 332-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 333-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 334-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 335-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 336-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 337-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 338-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 339-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 340-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 341-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 342-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s70)-[GOOD] (assert s82)-Fast allSat, Looking for solution 342-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 343-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 344-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 345-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 346-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 347-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 348-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 349-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 350-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 351-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 352-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 353-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 354-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s70)-[GOOD] (assert s83)-Fast allSat, Looking for solution 354-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 355-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 356-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 357-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 358-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 359-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 360-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 361-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 362-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 363-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 364-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 365-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 366-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s70)-[GOOD] (assert s87)-[GOOD] (define-fun s89 () Bool (= s1 s5))-[GOOD] (assert s89)-Fast allSat, Looking for solution 366-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 367-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 368-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 369-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 370-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 371-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 372-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 373-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 374-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 375-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 376-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 377-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 14))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 378-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s43)-[GOOD] (define-fun s90 () Bool (= s0 s38))-[GOOD] (assert s90)-Fast allSat, Looking for solution 378-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s86)-Fast allSat, Looking for solution 379-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s46)-Fast allSat, Looking for solution 380-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s47)-Fast allSat, Looking for solution 381-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s48)-Fast allSat, Looking for solution 382-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s49)-Fast allSat, Looking for solution 383-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s50)-Fast allSat, Looking for solution 384-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s51)-Fast allSat, Looking for solution 385-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s52)-Fast allSat, Looking for solution 386-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s53)-Fast allSat, Looking for solution 387-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s54)-Fast allSat, Looking for solution 388-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s55)-Fast allSat, Looking for solution 389-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s56)-Fast allSat, Looking for solution 390-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s57)-Fast allSat, Looking for solution 391-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s58)-[GOOD] (assert s59)-Fast allSat, Looking for solution 391-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 392-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 393-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 394-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 395-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 396-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 397-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 398-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 399-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 400-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 401-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 402-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 403-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s72)-[GOOD] (assert s73)-Fast allSat, Looking for solution 403-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 404-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 405-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 406-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 407-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 408-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 409-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 410-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 411-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 412-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 413-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 414-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 415-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s72)-[GOOD] (assert s74)-Fast allSat, Looking for solution 415-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 416-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 417-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 418-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 419-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 420-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 421-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 422-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 423-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 424-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 425-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 426-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 427-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s72)-[GOOD] (assert s75)-Fast allSat, Looking for solution 427-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 428-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 429-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 430-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 431-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 432-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 433-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 434-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 435-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 436-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 437-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 438-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 439-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s72)-[GOOD] (assert s76)-Fast allSat, Looking for solution 439-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 440-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 441-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 442-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 443-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 444-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 445-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 446-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 447-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 448-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 449-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 450-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 451-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s72)-[GOOD] (assert s77)-Fast allSat, Looking for solution 451-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 452-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 453-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 454-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 455-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 456-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 457-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 458-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 459-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 460-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 461-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 462-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 463-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s72)-[GOOD] (assert s78)-Fast allSat, Looking for solution 463-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 464-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 465-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 466-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 467-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 468-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 469-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 470-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 471-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 472-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 473-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 474-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 475-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s72)-[GOOD] (assert s79)-Fast allSat, Looking for solution 475-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 476-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 477-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 478-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 479-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 480-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 481-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 482-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 483-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 484-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 485-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 486-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 487-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s72)-[GOOD] (assert s80)-Fast allSat, Looking for solution 487-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 488-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 489-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 490-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 491-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 492-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 493-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 494-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 495-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 496-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 497-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 498-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 499-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s72)-[GOOD] (assert s81)-Fast allSat, Looking for solution 499-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 500-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 501-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 502-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 503-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 504-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 505-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 506-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 507-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 508-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 509-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 510-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 511-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s72)-[GOOD] (assert s82)-Fast allSat, Looking for solution 511-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 512-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 513-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 514-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 515-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 516-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 517-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 518-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 519-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 520-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 521-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 522-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 523-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s72)-[GOOD] (assert s83)-Fast allSat, Looking for solution 523-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 524-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 525-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 526-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 527-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 528-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 529-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 530-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 531-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 532-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 533-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 534-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 535-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s72)-[GOOD] (assert s89)-Fast allSat, Looking for solution 535-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 536-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 537-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 538-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 539-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 540-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 541-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 542-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 543-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 544-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 545-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 546-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 547-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s88)-[GOOD] (assert s90)-[GOOD] (assert s85)-Fast allSat, Looking for solution 547-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 548-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 549-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 550-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 551-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 552-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 553-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 554-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 555-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 556-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 557-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 558-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 13))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 559-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s45)-[GOOD] (define-fun s91 () Bool (= s0 s36))-[GOOD] (assert s91)-Fast allSat, Looking for solution 559-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s43)-Fast allSat, Looking for solution 560-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s86)-Fast allSat, Looking for solution 561-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s47)-Fast allSat, Looking for solution 562-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s48)-Fast allSat, Looking for solution 563-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s49)-Fast allSat, Looking for solution 564-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s50)-Fast allSat, Looking for solution 565-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s51)-Fast allSat, Looking for solution 566-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s52)-Fast allSat, Looking for solution 567-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s53)-Fast allSat, Looking for solution 568-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s54)-Fast allSat, Looking for solution 569-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s55)-Fast allSat, Looking for solution 570-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s56)-Fast allSat, Looking for solution 571-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s57)-Fast allSat, Looking for solution 572-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s70)-[GOOD] (assert s59)-Fast allSat, Looking for solution 572-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 573-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 574-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 575-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 576-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 577-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 578-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 579-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 580-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 581-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 582-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 583-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 584-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s72)-[GOOD] (assert s73)-Fast allSat, Looking for solution 584-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 585-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 586-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 587-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 588-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 589-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 590-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 591-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 592-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 593-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 594-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 595-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 596-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s58)-[GOOD] (assert s74)-Fast allSat, Looking for solution 596-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 597-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 598-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 599-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 600-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 601-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 602-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 603-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 604-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 605-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 606-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 607-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 608-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s60)-[GOOD] (assert s75)-Fast allSat, Looking for solution 608-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 609-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 610-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 611-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 612-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 613-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 614-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 615-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 616-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 617-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 618-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 619-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 620-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s61)-[GOOD] (assert s76)-Fast allSat, Looking for solution 620-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 621-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 622-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 623-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 624-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 625-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 626-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 627-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 628-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 629-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 630-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 631-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 632-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s62)-[GOOD] (assert s77)-Fast allSat, Looking for solution 632-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 633-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 634-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 635-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 636-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 637-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 638-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 639-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 640-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 641-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 642-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 643-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 644-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s63)-[GOOD] (assert s78)-Fast allSat, Looking for solution 644-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 645-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 646-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 647-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 648-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 649-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 650-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 651-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 652-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 653-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 654-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 655-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 656-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s64)-[GOOD] (assert s79)-Fast allSat, Looking for solution 656-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 657-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 658-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 659-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 660-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 661-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 662-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 663-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 664-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 665-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 666-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 667-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 668-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s65)-[GOOD] (assert s80)-Fast allSat, Looking for solution 668-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 669-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 670-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 671-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 672-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 673-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 674-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 675-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 676-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 677-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 678-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 679-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 680-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s66)-[GOOD] (assert s81)-Fast allSat, Looking for solution 680-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 681-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 682-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 683-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 684-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 685-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 686-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 687-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 688-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 689-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 690-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 691-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 692-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s67)-[GOOD] (assert s82)-Fast allSat, Looking for solution 692-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 693-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 694-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 695-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 696-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 697-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 698-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 699-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 700-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 701-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 702-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 703-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 704-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s68)-[GOOD] (assert s89)-Fast allSat, Looking for solution 704-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 705-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 706-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 707-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 708-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 709-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 710-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 711-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 712-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 713-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 714-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 715-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 716-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s68)-[GOOD] (assert s85)-Fast allSat, Looking for solution 716-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 717-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 718-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 719-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 720-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 721-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 722-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 723-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 724-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 725-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 726-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 727-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 728-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s71)-[GOOD] (assert s91)-[GOOD] (assert s84)-Fast allSat, Looking for solution 728-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 729-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 730-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 731-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 732-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 733-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 734-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 735-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 736-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 737-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 738-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 739-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 12))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 740-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s46)-[GOOD] (define-fun s92 () Bool (= s0 s34))-[GOOD] (assert s92)-Fast allSat, Looking for solution 740-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s45)-Fast allSat, Looking for solution 741-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s43)-Fast allSat, Looking for solution 742-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s48)-Fast allSat, Looking for solution 743-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s49)-Fast allSat, Looking for solution 744-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s50)-Fast allSat, Looking for solution 745-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s51)-Fast allSat, Looking for solution 746-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s52)-Fast allSat, Looking for solution 747-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s53)-Fast allSat, Looking for solution 748-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s54)-Fast allSat, Looking for solution 749-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s55)-Fast allSat, Looking for solution 750-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s56)-Fast allSat, Looking for solution 751-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s57)-Fast allSat, Looking for solution 752-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s86)-Fast allSat, Looking for solution 753-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s69)-[GOOD] (assert s89)-Fast allSat, Looking for solution 753-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 754-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 755-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 756-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 757-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 758-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 759-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 760-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 761-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 762-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 763-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 764-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 765-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s69)-[GOOD] (assert s59)-Fast allSat, Looking for solution 765-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 766-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 767-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 768-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 769-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 770-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 771-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 772-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 773-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 774-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 775-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 776-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 777-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s69)-[GOOD] (assert s73)-Fast allSat, Looking for solution 777-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 778-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 779-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 780-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 781-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 782-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 783-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 784-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 785-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 786-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 787-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 788-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 789-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s69)-[GOOD] (assert s74)-Fast allSat, Looking for solution 789-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 790-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 791-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 792-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 793-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 794-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 795-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 796-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 797-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 798-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 799-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 800-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 801-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s69)-[GOOD] (assert s75)-Fast allSat, Looking for solution 801-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 802-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 803-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 804-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 805-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 806-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 807-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 808-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 809-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 810-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 811-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 812-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 813-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s69)-[GOOD] (assert s76)-Fast allSat, Looking for solution 813-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 814-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 815-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 816-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 817-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 818-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 819-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 820-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 821-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 822-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 823-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 824-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 825-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s69)-[GOOD] (assert s77)-Fast allSat, Looking for solution 825-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 826-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 827-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 828-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 829-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 830-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 831-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 832-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 833-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 834-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 835-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 836-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 837-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s69)-[GOOD] (assert s78)-Fast allSat, Looking for solution 837-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 838-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 839-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 840-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 841-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 842-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 843-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 844-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 845-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 846-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 847-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 848-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 849-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s69)-[GOOD] (assert s79)-Fast allSat, Looking for solution 849-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 850-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 851-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 852-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 853-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 854-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 855-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 856-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 857-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 858-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 859-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 860-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 861-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s69)-[GOOD] (assert s80)-Fast allSat, Looking for solution 861-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 862-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 863-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 864-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 865-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 866-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 867-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 868-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 869-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 870-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 871-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 872-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 873-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s69)-[GOOD] (assert s81)-Fast allSat, Looking for solution 873-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 874-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 875-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 876-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 877-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 878-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 879-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 880-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 881-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 882-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 883-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 884-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 885-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s88)-[GOOD] (assert s85)-Fast allSat, Looking for solution 885-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 886-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 887-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 888-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 889-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 890-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 891-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 892-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 893-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 894-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 895-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 896-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 897-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s71)-[GOOD] (assert s84)-Fast allSat, Looking for solution 897-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 898-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 899-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 900-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 901-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 902-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 903-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 904-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 905-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 906-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 907-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 908-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 909-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s70)-[GOOD] (assert s92)-[GOOD] (assert s83)-Fast allSat, Looking for solution 909-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 910-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 911-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 912-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 913-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 914-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 915-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 916-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 917-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 918-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 919-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 920-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 11))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 921-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s47)-[GOOD] (define-fun s93 () Bool (= s0 s32))-[GOOD] (assert s93)-Fast allSat, Looking for solution 921-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s46)-Fast allSat, Looking for solution 922-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s45)-Fast allSat, Looking for solution 923-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s43)-Fast allSat, Looking for solution 924-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s49)-Fast allSat, Looking for solution 925-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s50)-Fast allSat, Looking for solution 926-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s51)-Fast allSat, Looking for solution 927-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s52)-Fast allSat, Looking for solution 928-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s53)-Fast allSat, Looking for solution 929-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s54)-Fast allSat, Looking for solution 930-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s55)-Fast allSat, Looking for solution 931-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s56)-Fast allSat, Looking for solution 932-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s57)-Fast allSat, Looking for solution 933-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s86)-Fast allSat, Looking for solution 934-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s68)-[GOOD] (assert s89)-Fast allSat, Looking for solution 934-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 935-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 936-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 937-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 938-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 939-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 940-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 941-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 942-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 943-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 944-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 945-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 946-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s68)-[GOOD] (assert s59)-Fast allSat, Looking for solution 946-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 947-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 948-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 949-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 950-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 951-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 952-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 953-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 954-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 955-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 956-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 957-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 958-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s68)-[GOOD] (assert s73)-Fast allSat, Looking for solution 958-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 959-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 960-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 961-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 962-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 963-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 964-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 965-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 966-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 967-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 968-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 969-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 970-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s68)-[GOOD] (assert s74)-Fast allSat, Looking for solution 970-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 971-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 972-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 973-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 974-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 975-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 976-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 977-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 978-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 979-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 980-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 981-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 982-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s68)-[GOOD] (assert s75)-Fast allSat, Looking for solution 982-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 983-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 984-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 985-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 986-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 987-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 988-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 989-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 990-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 991-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 992-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 993-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 994-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s68)-[GOOD] (assert s76)-Fast allSat, Looking for solution 994-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 995-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 996-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 997-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 998-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 999-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 1000-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 1001-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 1002-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1003-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1004-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1005-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1006-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s68)-[GOOD] (assert s77)-Fast allSat, Looking for solution 1006-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1007-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1008-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1009-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1010-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 1011-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 1012-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 1013-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1014-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1015-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1016-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1017-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1018-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s68)-[GOOD] (assert s78)-Fast allSat, Looking for solution 1018-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1019-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1020-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1021-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1022-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 1023-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 1024-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 1025-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1026-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1027-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1028-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1029-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1030-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s68)-[GOOD] (assert s79)-Fast allSat, Looking for solution 1030-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1031-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1032-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1033-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1034-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 1035-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 1036-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 1037-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1038-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1039-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1040-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1041-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1042-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s68)-[GOOD] (assert s80)-Fast allSat, Looking for solution 1042-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1043-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1044-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1045-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1046-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 1047-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 1048-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 1049-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1050-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1051-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1052-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1053-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1054-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s88)-[GOOD] (assert s85)-Fast allSat, Looking for solution 1054-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1055-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1056-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1057-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 1058-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 1059-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 1060-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 1061-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1062-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1063-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1064-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1065-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1066-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s71)-[GOOD] (assert s84)-Fast allSat, Looking for solution 1066-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1067-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1068-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 1069-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 1070-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 1071-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 1072-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1073-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1074-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1075-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1076-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1077-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1078-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s71)-[GOOD] (assert s83)-Fast allSat, Looking for solution 1078-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1079-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1080-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1081-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 1082-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 1083-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 1084-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 1085-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1086-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1087-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1088-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1089-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1090-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s69)-[GOOD] (assert s93)-[GOOD] (assert s82)-Fast allSat, Looking for solution 1090-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 1091-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 1092-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 1093-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 1094-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1095-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1096-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1097-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1098-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1099-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1100-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1101-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 10))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1102-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s48)-[GOOD] (define-fun s94 () Bool (= s0 s30))-[GOOD] (assert s94)-Fast allSat, Looking for solution 1102-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s47)-Fast allSat, Looking for solution 1103-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s46)-Fast allSat, Looking for solution 1104-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s45)-Fast allSat, Looking for solution 1105-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s43)-Fast allSat, Looking for solution 1106-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s50)-Fast allSat, Looking for solution 1107-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s51)-Fast allSat, Looking for solution 1108-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s52)-Fast allSat, Looking for solution 1109-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s53)-Fast allSat, Looking for solution 1110-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s54)-Fast allSat, Looking for solution 1111-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s55)-Fast allSat, Looking for solution 1112-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s56)-Fast allSat, Looking for solution 1113-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s57)-Fast allSat, Looking for solution 1114-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s86)-Fast allSat, Looking for solution 1115-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s67)-[GOOD] (assert s89)-Fast allSat, Looking for solution 1115-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1116-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1117-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1118-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1119-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 1120-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 1121-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 1122-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1123-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1124-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1125-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1126-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1127-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s67)-[GOOD] (assert s59)-Fast allSat, Looking for solution 1127-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1128-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1129-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1130-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1131-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1132-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 1133-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 1134-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 1135-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1136-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1137-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1138-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1139-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s67)-[GOOD] (assert s73)-Fast allSat, Looking for solution 1139-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1140-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1141-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1142-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1143-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1144-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 1145-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 1146-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 1147-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1148-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1149-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1150-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1151-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s67)-[GOOD] (assert s74)-Fast allSat, Looking for solution 1151-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1152-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1153-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1154-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1155-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 1156-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 1157-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 1158-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1159-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1160-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1161-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1162-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1163-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s67)-[GOOD] (assert s75)-Fast allSat, Looking for solution 1163-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1164-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1165-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1166-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1167-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1168-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 1169-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 1170-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 1171-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1172-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1173-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1174-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1175-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s67)-[GOOD] (assert s76)-Fast allSat, Looking for solution 1175-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1176-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1177-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1178-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1179-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1180-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1181-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1182-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1183-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1184-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 1185-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 1186-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 1187-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s67)-[GOOD] (assert s77)-Fast allSat, Looking for solution 1187-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1188-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1189-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1190-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1191-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1192-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1193-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1194-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1195-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1196-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1197-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 1198-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 1199-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s67)-[GOOD] (assert s78)-Fast allSat, Looking for solution 1199-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1200-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1201-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1202-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 1203-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1204-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1205-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1206-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1207-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1208-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1209-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1210-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 1211-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s67)-[GOOD] (assert s79)-Fast allSat, Looking for solution 1211-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1212-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1213-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 1214-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 1215-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1216-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1217-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1218-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1219-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1220-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1221-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1222-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1223-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s88)-[GOOD] (assert s85)-Fast allSat, Looking for solution 1223-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 1224-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1225-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1226-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1227-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 1228-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 1229-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 1230-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1231-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1232-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1233-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1234-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1235-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s71)-[GOOD] (assert s84)-Fast allSat, Looking for solution 1235-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1236-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1237-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 1238-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 1239-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 1240-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 1241-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1242-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1243-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1244-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1245-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1246-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1247-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s71)-[GOOD] (assert s83)-Fast allSat, Looking for solution 1247-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1248-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1249-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1250-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 1251-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 1252-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 1253-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 1254-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1255-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1256-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1257-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1258-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1259-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s71)-[GOOD] (assert s82)-Fast allSat, Looking for solution 1259-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 1260-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 1261-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 1262-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 1263-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1264-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1265-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1266-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1267-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1268-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1269-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1270-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1271-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s68)-[GOOD] (assert s94)-[GOOD] (assert s81)-Fast allSat, Looking for solution 1271-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1272-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1273-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1274-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1275-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 1276-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 1277-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 1278-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1279-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1280-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1281-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1282-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 9))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1283-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s49)-[GOOD] (define-fun s95 () Bool (= s0 s28))-[GOOD] (assert s95)-Fast allSat, Looking for solution 1283-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s48)-Fast allSat, Looking for solution 1284-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s47)-Fast allSat, Looking for solution 1285-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s46)-Fast allSat, Looking for solution 1286-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s45)-Fast allSat, Looking for solution 1287-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s43)-Fast allSat, Looking for solution 1288-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s86)-Fast allSat, Looking for solution 1289-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s51)-Fast allSat, Looking for solution 1290-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s52)-Fast allSat, Looking for solution 1291-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s53)-Fast allSat, Looking for solution 1292-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s54)-Fast allSat, Looking for solution 1293-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s55)-Fast allSat, Looking for solution 1294-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s56)-Fast allSat, Looking for solution 1295-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s57)-Fast allSat, Looking for solution 1296-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s66)-[GOOD] (assert s59)-Fast allSat, Looking for solution 1296-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 1297-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1298-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1299-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1300-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1301-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1302-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 1303-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 1304-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1305-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1306-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1307-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1308-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s72)-[GOOD] (assert s73)-Fast allSat, Looking for solution 1308-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 1309-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 1310-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1311-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1312-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1313-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1314-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1315-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 1316-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 1317-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1318-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1319-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1320-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s58)-[GOOD] (assert s74)-Fast allSat, Looking for solution 1320-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 1321-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 1322-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1323-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1324-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1325-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1326-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1327-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 1328-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 1329-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1330-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1331-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1332-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s60)-[GOOD] (assert s75)-Fast allSat, Looking for solution 1332-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1333-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1334-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 1335-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 1336-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1337-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1338-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1339-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1340-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1341-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 1342-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 1343-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1344-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s61)-[GOOD] (assert s76)-Fast allSat, Looking for solution 1344-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1345-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1346-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1347-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 1348-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 1349-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 1350-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 1351-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1352-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1353-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1354-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1355-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1356-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s62)-[GOOD] (assert s77)-Fast allSat, Looking for solution 1356-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1357-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1358-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1359-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1360-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1361-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 1362-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 1363-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 1364-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1365-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1366-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1367-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1368-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s63)-[GOOD] (assert s78)-Fast allSat, Looking for solution 1368-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1369-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1370-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1371-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1372-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1373-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 1374-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 1375-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1376-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1377-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1378-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1379-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1380-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s66)-[GOOD] (assert s89)-Fast allSat, Looking for solution 1380-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 1381-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1382-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1383-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1384-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1385-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 1386-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 1387-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1388-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1389-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1390-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1391-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1392-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s66)-[GOOD] (assert s85)-Fast allSat, Looking for solution 1392-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 1393-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1394-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1395-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1396-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 1397-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 1398-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1399-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1400-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1401-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1402-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1403-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1404-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s66)-[GOOD] (assert s84)-Fast allSat, Looking for solution 1404-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1405-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1406-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1407-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1408-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 1409-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 1410-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 1411-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1412-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1413-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1414-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1415-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1416-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s66)-[GOOD] (assert s83)-Fast allSat, Looking for solution 1416-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 1417-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1418-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 1419-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 1420-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1421-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1422-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1423-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1424-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1425-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1426-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1427-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1428-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s66)-[GOOD] (assert s82)-Fast allSat, Looking for solution 1428-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1429-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1430-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1431-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1432-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 1433-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 1434-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 1435-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1436-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1437-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1438-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1439-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1440-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s66)-[GOOD] (assert s81)-Fast allSat, Looking for solution 1440-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1441-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1442-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1443-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1444-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1445-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 1446-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 1447-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1448-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1449-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1450-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1451-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1452-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s67)-[GOOD] (assert s95)-[GOOD] (assert s80)-Fast allSat, Looking for solution 1452-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 1453-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 1454-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1455-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1456-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1457-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1458-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1459-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1460-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1461-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1462-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1463-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 8))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1464-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s50)-[GOOD] (define-fun s96 () Bool (= s0 s26))-[GOOD] (assert s96)-Fast allSat, Looking for solution 1464-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s49)-Fast allSat, Looking for solution 1465-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s48)-Fast allSat, Looking for solution 1466-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s47)-Fast allSat, Looking for solution 1467-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s46)-Fast allSat, Looking for solution 1468-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s45)-Fast allSat, Looking for solution 1469-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s43)-Fast allSat, Looking for solution 1470-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s52)-Fast allSat, Looking for solution 1471-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s53)-Fast allSat, Looking for solution 1472-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s54)-Fast allSat, Looking for solution 1473-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s55)-Fast allSat, Looking for solution 1474-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s56)-Fast allSat, Looking for solution 1475-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s57)-Fast allSat, Looking for solution 1476-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s86)-Fast allSat, Looking for solution 1477-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s71)-[GOOD] (assert s89)-Fast allSat, Looking for solution 1477-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1478-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1479-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1480-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 1481-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 1482-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 1483-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 1484-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1485-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1486-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1487-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1488-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1489-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s65)-[GOOD] (assert s59)-Fast allSat, Looking for solution 1489-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 1490-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1491-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1492-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1493-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1494-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 1495-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 1496-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1497-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1498-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1499-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1500-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1501-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s65)-[GOOD] (assert s73)-Fast allSat, Looking for solution 1501-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1502-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1503-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1504-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1505-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1506-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 1507-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 1508-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 1509-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1510-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1511-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1512-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1513-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s65)-[GOOD] (assert s74)-Fast allSat, Looking for solution 1513-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1514-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1515-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1516-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1517-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 1518-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 1519-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 1520-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1521-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1522-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1523-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1524-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1525-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s65)-[GOOD] (assert s75)-Fast allSat, Looking for solution 1525-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1526-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1527-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1528-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1529-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1530-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 1531-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 1532-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 1533-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1534-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1535-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1536-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1537-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s65)-[GOOD] (assert s76)-Fast allSat, Looking for solution 1537-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1538-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1539-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1540-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1541-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 1542-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 1543-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1544-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1545-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1546-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1547-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1548-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 1549-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s65)-[GOOD] (assert s77)-Fast allSat, Looking for solution 1549-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1550-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1551-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1552-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1553-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1554-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 1555-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 1556-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1557-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1558-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1559-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1560-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1561-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s88)-[GOOD] (assert s85)-Fast allSat, Looking for solution 1561-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 1562-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 1563-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 1564-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1565-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1566-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1567-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 1568-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1569-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1570-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1571-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1572-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1573-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s71)-[GOOD] (assert s84)-Fast allSat, Looking for solution 1573-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 1574-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 1575-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 1576-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1577-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1578-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 1579-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1580-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1581-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1582-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1583-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1584-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1585-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s70)-[GOOD] (assert s83)-Fast allSat, Looking for solution 1585-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 1586-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 1587-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 1588-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1589-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 1590-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1591-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1592-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1593-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1594-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1595-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1596-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1597-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s70)-[GOOD] (assert s82)-Fast allSat, Looking for solution 1597-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 1598-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 1599-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 1600-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 1601-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1602-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1603-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1604-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1605-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1606-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1607-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1608-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1609-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s70)-[GOOD] (assert s81)-Fast allSat, Looking for solution 1609-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 1610-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 1611-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 1612-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1613-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1614-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1615-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1616-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1617-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1618-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1619-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1620-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1621-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s70)-[GOOD] (assert s80)-Fast allSat, Looking for solution 1621-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 1622-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 1623-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1624-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1625-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1626-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1627-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1628-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1629-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1630-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1631-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1632-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 1633-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s66)-[GOOD] (assert s96)-[GOOD] (assert s79)-Fast allSat, Looking for solution 1633-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 1634-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1635-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1636-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1637-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1638-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1639-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 1640-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1641-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1642-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1643-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1644-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 7))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1645-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s51)-[GOOD] (define-fun s97 () Bool (= s0 s24))-[GOOD] (assert s97)-Fast allSat, Looking for solution 1645-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s50)-Fast allSat, Looking for solution 1646-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s49)-Fast allSat, Looking for solution 1647-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s48)-Fast allSat, Looking for solution 1648-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s47)-Fast allSat, Looking for solution 1649-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s46)-Fast allSat, Looking for solution 1650-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s45)-Fast allSat, Looking for solution 1651-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s43)-Fast allSat, Looking for solution 1652-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s86)-Fast allSat, Looking for solution 1653-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s53)-Fast allSat, Looking for solution 1654-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s54)-Fast allSat, Looking for solution 1655-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s55)-Fast allSat, Looking for solution 1656-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s56)-Fast allSat, Looking for solution 1657-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s57)-Fast allSat, Looking for solution 1658-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s64)-[GOOD] (assert s59)-Fast allSat, Looking for solution 1658-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 1659-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 1660-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1661-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 1662-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1663-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1664-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1665-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1666-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1667-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1668-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1669-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1670-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s72)-[GOOD] (assert s73)-Fast allSat, Looking for solution 1670-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1671-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1672-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1673-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1674-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 1675-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 1676-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 1677-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 1678-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1679-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1680-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1681-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1682-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s58)-[GOOD] (assert s74)-Fast allSat, Looking for solution 1682-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1683-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 1684-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 1685-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 1686-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1687-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 1688-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1689-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1690-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1691-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1692-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1693-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1694-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s60)-[GOOD] (assert s75)-Fast allSat, Looking for solution 1694-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1695-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1696-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 1697-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 1698-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 1699-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1700-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 1701-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1702-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1703-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1704-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1705-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1706-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s61)-[GOOD] (assert s76)-Fast allSat, Looking for solution 1706-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1707-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1708-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1709-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 1710-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 1711-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 1712-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 1713-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1714-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1715-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1716-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1717-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1718-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s71)-[GOOD] (assert s89)-Fast allSat, Looking for solution 1718-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1719-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1720-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1721-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 1722-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 1723-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 1724-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 1725-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1726-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1727-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1728-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1729-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1730-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s70)-[GOOD] (assert s85)-Fast allSat, Looking for solution 1730-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 1731-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 1732-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 1733-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 1734-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1735-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1736-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1737-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1738-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1739-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1740-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1741-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1742-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s69)-[GOOD] (assert s84)-Fast allSat, Looking for solution 1742-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 1743-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 1744-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 1745-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 1746-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1747-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1748-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1749-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1750-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1751-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1752-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1753-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1754-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s68)-[GOOD] (assert s83)-Fast allSat, Looking for solution 1754-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1755-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1756-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1757-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 1758-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 1759-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 1760-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 1761-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1762-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1763-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1764-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1765-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1766-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s67)-[GOOD] (assert s82)-Fast allSat, Looking for solution 1766-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 1767-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 1768-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 1769-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1770-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1771-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1772-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1773-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1774-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1775-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1776-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1777-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1778-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s66)-[GOOD] (assert s81)-Fast allSat, Looking for solution 1778-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1779-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1780-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1781-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1782-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1783-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 1784-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 1785-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1786-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1787-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1788-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1789-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1790-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s65)-[GOOD] (assert s80)-Fast allSat, Looking for solution 1790-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 1791-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1792-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1793-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1794-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1795-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1796-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 1797-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1798-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1799-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1800-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1801-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1802-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s64)-[GOOD] (assert s79)-Fast allSat, Looking for solution 1802-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1803-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1804-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1805-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1806-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1807-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 1808-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 1809-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1810-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1811-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1812-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1813-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1814-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s65)-[GOOD] (assert s97)-[GOOD] (assert s78)-Fast allSat, Looking for solution 1814-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1815-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1816-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1817-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1818-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1819-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 1820-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 1821-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1822-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1823-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1824-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1825-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 6))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1826-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s52)-[GOOD] (define-fun s98 () Bool (= s0 s22))-[GOOD] (assert s98)-Fast allSat, Looking for solution 1826-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s51)-Fast allSat, Looking for solution 1827-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s50)-Fast allSat, Looking for solution 1828-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s49)-Fast allSat, Looking for solution 1829-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s48)-Fast allSat, Looking for solution 1830-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s47)-Fast allSat, Looking for solution 1831-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s46)-Fast allSat, Looking for solution 1832-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s45)-Fast allSat, Looking for solution 1833-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s43)-Fast allSat, Looking for solution 1834-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s54)-Fast allSat, Looking for solution 1835-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s55)-Fast allSat, Looking for solution 1836-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s56)-Fast allSat, Looking for solution 1837-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s57)-Fast allSat, Looking for solution 1838-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s86)-Fast allSat, Looking for solution 1839-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s63)-[GOOD] (assert s89)-Fast allSat, Looking for solution 1839-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 1840-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 1841-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 1842-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 1843-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1844-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1845-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1846-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1847-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1848-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1849-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1850-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1851-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s63)-[GOOD] (assert s59)-Fast allSat, Looking for solution 1851-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1852-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1853-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1854-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 1855-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 1856-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 1857-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 1858-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1859-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1860-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1861-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1862-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1863-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s63)-[GOOD] (assert s73)-Fast allSat, Looking for solution 1863-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1864-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1865-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1866-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1867-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1868-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 1869-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 1870-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 1871-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 1872-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1873-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1874-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1875-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s63)-[GOOD] (assert s74)-Fast allSat, Looking for solution 1875-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1876-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1877-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1878-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 1879-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 1880-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 1881-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 1882-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1883-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1884-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1885-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1886-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1887-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s63)-[GOOD] (assert s75)-Fast allSat, Looking for solution 1887-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1888-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1889-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1890-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1891-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1892-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 1893-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 1894-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 1895-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 1896-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1897-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1898-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1899-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s88)-[GOOD] (assert s85)-Fast allSat, Looking for solution 1899-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 1900-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 1901-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 1902-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 1903-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 1904-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1905-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1906-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1907-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1908-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1909-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1910-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1911-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s71)-[GOOD] (assert s84)-Fast allSat, Looking for solution 1911-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1912-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1913-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 1914-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 1915-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 1916-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 1917-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 1918-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1919-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1920-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1921-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1922-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1923-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s70)-[GOOD] (assert s83)-Fast allSat, Looking for solution 1923-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1924-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1925-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1926-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 1927-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 1928-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 1929-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 1930-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 1931-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1932-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1933-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1934-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1935-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s69)-[GOOD] (assert s82)-Fast allSat, Looking for solution 1935-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 1936-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 1937-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 1938-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 1939-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 1940-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1941-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1942-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1943-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1944-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1945-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1946-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1947-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s68)-[GOOD] (assert s81)-Fast allSat, Looking for solution 1947-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1948-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1949-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1950-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1951-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 1952-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 1953-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 1954-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 1955-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1956-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1957-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1958-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1959-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s67)-[GOOD] (assert s80)-Fast allSat, Looking for solution 1959-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 1960-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 1961-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 1962-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1963-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1964-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1965-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1966-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1967-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1968-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1969-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1970-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1971-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s67)-[GOOD] (assert s79)-Fast allSat, Looking for solution 1971-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 1972-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1973-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1974-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1975-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1976-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1977-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 1978-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 1979-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1980-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1981-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1982-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1983-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s67)-[GOOD] (assert s78)-Fast allSat, Looking for solution 1983-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 1984-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1985-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1986-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1987-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1988-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 1989-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 1990-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1991-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1992-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1993-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1994-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1995-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s64)-[GOOD] (assert s98)-[GOOD] (assert s77)-Fast allSat, Looking for solution 1995-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1996-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1997-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1998-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1999-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 2000-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 2001-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 2002-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 2003-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 2004-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 2005-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 2006-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 5))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 2007-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s53)-[GOOD] (define-fun s99 () Bool (= s0 s20))-[GOOD] (assert s99)-Fast allSat, Looking for solution 2007-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s52)-Fast allSat, Looking for solution 2008-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s51)-Fast allSat, Looking for solution 2009-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s50)-Fast allSat, Looking for solution 2010-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s49)-Fast allSat, Looking for solution 2011-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s48)-Fast allSat, Looking for solution 2012-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s47)-Fast allSat, Looking for solution 2013-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s46)-Fast allSat, Looking for solution 2014-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s45)-Fast allSat, Looking for solution 2015-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s43)-Fast allSat, Looking for solution 2016-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s86)-Fast allSat, Looking for solution 2017-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s55)-Fast allSat, Looking for solution 2018-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s56)-Fast allSat, Looking for solution 2019-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s57)-Fast allSat, Looking for solution 2020-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s58)-[GOOD] (assert s59)-Fast allSat, Looking for solution 2020-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 2021-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 2022-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 2023-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 2024-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 2025-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 2026-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 2027-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 2028-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 2029-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 2030-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 2031-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 2032-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s72)-[GOOD] (assert s73)-Fast allSat, Looking for solution 2032-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 2033-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 2034-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 2035-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 2036-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 2037-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 2038-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 2039-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 2040-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 2041-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 2042-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 2043-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 2044-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s58)-[GOOD] (assert s74)-Fast allSat, Looking for solution 2044-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 2045-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 2046-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 2047-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 2048-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 2049-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 2050-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 2051-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 2052-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 2053-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 2054-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 2055-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 2056-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s71)-[GOOD] (assert s89)-Fast allSat, Looking for solution 2056-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 2057-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 2058-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 2059-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 2060-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 2061-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 2062-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 2063-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 2064-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 2065-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 2066-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 2067-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 2068-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s70)-[GOOD] (assert s85)-Fast allSat, Looking for solution 2068-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 2069-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 2070-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 2071-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 2072-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 2073-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 2074-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 2075-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 2076-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 2077-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 2078-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 2079-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 2080-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s69)-[GOOD] (assert s84)-Fast allSat, Looking for solution 2080-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 2081-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 2082-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 2083-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 2084-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 2085-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 2086-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 2087-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 2088-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 2089-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 2090-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 2091-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 2092-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s68)-[GOOD] (assert s83)-Fast allSat, Looking for solution 2092-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 2093-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 2094-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 2095-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 2096-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 2097-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 2098-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 2099-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 2100-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 2101-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 2102-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 2103-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 2104-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s67)-[GOOD] (assert s82)-Fast allSat, Looking for solution 2104-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 2105-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 2106-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 2107-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 2108-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 2109-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 2110-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 2111-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 2112-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 2113-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 2114-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 2115-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 2116-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s66)-[GOOD] (assert s81)-Fast allSat, Looking for solution 2116-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 2117-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 2118-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 2119-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 2120-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 2121-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 2122-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 2123-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 2124-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 2125-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 2126-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 2127-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 2128-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s65)-[GOOD] (assert s80)-Fast allSat, Looking for solution 2128-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 2129-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 2130-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 2131-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 2132-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 2133-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 2134-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 2135-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 2136-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 2137-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 2138-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 2139-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 2140-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s64)-[GOOD] (assert s79)-Fast allSat, Looking for solution 2140-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 2141-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 2142-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 2143-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 2144-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 2145-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 2146-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 2147-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 2148-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 2149-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 2150-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 2151-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 2152-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s63)-[GOOD] (assert s78)-Fast allSat, Looking for solution 2152-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 2153-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 2154-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 2155-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 2156-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 2157-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 2158-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 2159-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 2160-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 2161-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 2162-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 2163-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 2164-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s62)-[GOOD] (assert s77)-Fast allSat, Looking for solution 2164-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 2165-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 2166-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 2167-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 2168-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 2169-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 2170-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 2171-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 2172-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 2173-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 2174-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 2175-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 2176-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s63)-[GOOD] (assert s99)-[GOOD] (assert s76)-Fast allSat, Looking for solution 2176-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 2177-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 2178-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 2179-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 2180-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 2181-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 2182-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 2183-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 2184-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 2185-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 2186-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 2187-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 4))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 2188-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s54)-[GOOD] (define-fun s100 () Bool (= s0 s18))-[GOOD] (assert s100)-Fast allSat, Looking for solution 2188-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s53)-Fast allSat, Looking for solution 2189-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s52)-Fast allSat, Looking for solution 2190-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s51)-Fast allSat, Looking for solution 2191-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s50)-Fast allSat, Looking for solution 2192-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s49)-Fast allSat, Looking for solution 2193-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s48)-Fast allSat, Looking for solution 2194-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s47)-Fast allSat, Looking for solution 2195-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s46)-Fast allSat, Looking for solution 2196-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s45)-Fast allSat, Looking for solution 2197-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s43)-Fast allSat, Looking for solution 2198-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s86)-Fast allSat, Looking for solution 2199-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s56)-Fast allSat, Looking for solution 2200-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s57)-Fast allSat, Looking for solution 2201-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s58)-[GOOD] (assert s59)-Fast allSat, Looking for solution 2201-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 2202-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 2203-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 2204-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 2205-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 2206-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 2207-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 2208-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 2209-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 2210-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 2211-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 2212-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 2213-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s72)-[GOOD] (assert s73)-Fast allSat, Looking for solution 2213-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 2214-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 2215-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 2216-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 2217-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 2218-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 2219-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 2220-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 2221-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 2222-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 2223-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 2224-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 2225-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s71)-[GOOD] (assert s89)-Fast allSat, Looking for solution 2225-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 2226-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 2227-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 2228-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 2229-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 2230-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 2231-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 2232-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 2233-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 2234-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 2235-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 2236-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 2237-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s88)-[GOOD] (assert s85)-Fast allSat, Looking for solution 2237-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 2238-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 2239-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 2240-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 2241-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 2242-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 2243-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 2244-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 2245-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 2246-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 2247-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 2248-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 2249-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s71)-[GOOD] (assert s84)-Fast allSat, Looking for solution 2249-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 2250-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 2251-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 2252-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 2253-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 2254-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 2255-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 2256-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 2257-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 2258-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 2259-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 2260-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 2261-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s70)-[GOOD] (assert s83)-Fast allSat, Looking for solution 2261-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 2262-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 2263-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 2264-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 2265-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 2266-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 2267-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 2268-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 2269-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 2270-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 2271-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 2272-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 2273-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s69)-[GOOD] (assert s82)-Fast allSat, Looking for solution 2273-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 2274-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 2275-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 2276-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 2277-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 2278-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 2279-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 2280-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 2281-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 2282-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 2283-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 2284-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 2285-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s68)-[GOOD] (assert s81)-Fast allSat, Looking for solution 2285-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 2286-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 2287-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 2288-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 2289-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 2290-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 2291-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 2292-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 2293-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 2294-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 2295-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 2296-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 2297-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s67)-[GOOD] (assert s80)-Fast allSat, Looking for solution 2297-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 2298-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 2299-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 2300-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 2301-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 2302-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 2303-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 2304-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 2305-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 2306-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 2307-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 2308-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 2309-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s66)-[GOOD] (assert s79)-Fast allSat, Looking for solution 2309-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 2310-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 2311-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 2312-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 2313-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 2314-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 2315-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 2316-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 2317-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 2318-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 2319-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 2320-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 2321-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s66)-[GOOD] (assert s78)-Fast allSat, Looking for solution 2321-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 2322-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 2323-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 2324-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 2325-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 2326-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 2327-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 2328-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 2329-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 2330-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 2331-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 2332-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 2333-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s66)-[GOOD] (assert s77)-Fast allSat, Looking for solution 2333-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 2334-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 2335-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 2336-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 2337-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 2338-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 2339-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 2340-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 2341-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 2342-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 2343-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 2344-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 2345-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s66)-[GOOD] (assert s76)-Fast allSat, Looking for solution 2345-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 2346-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 2347-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 2348-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 2349-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 2350-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 2351-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 2352-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 2353-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 2354-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 2355-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 2356-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 2357-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s62)-[GOOD] (assert s100)-[GOOD] (assert s75)-Fast allSat, Looking for solution 2357-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 2358-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 2359-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 2360-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 2361-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 2362-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 2363-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 2364-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 2365-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 2366-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 2367-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 2368-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 3))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 2369-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s55)-[GOOD] (define-fun s101 () Bool (= s0 s16))-[GOOD] (assert s101)-Fast allSat, Looking for solution 2369-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s54)-Fast allSat, Looking for solution 2370-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s53)-Fast allSat, Looking for solution 2371-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s52)-Fast allSat, Looking for solution 2372-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s51)-Fast allSat, Looking for solution 2373-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s50)-Fast allSat, Looking for solution 2374-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s49)-Fast allSat, Looking for solution 2375-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s48)-Fast allSat, Looking for solution 2376-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s47)-Fast allSat, Looking for solution 2377-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s46)-Fast allSat, Looking for solution 2378-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s45)-Fast allSat, Looking for solution 2379-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s43)-Fast allSat, Looking for solution 2380-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s86)-Fast allSat, Looking for solution 2381-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s57)-Fast allSat, Looking for solution 2382-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s60)-[GOOD] (assert s59)-Fast allSat, Looking for solution 2382-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 2383-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 2384-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 2385-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 2386-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 2387-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 2388-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 2389-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 2390-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 2391-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 2392-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 2393-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 2394-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s71)-[GOOD] (assert s89)-Fast allSat, Looking for solution 2394-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 2395-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 2396-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 2397-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 2398-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 2399-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 2400-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 2401-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 2402-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 2403-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 2404-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 2405-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 2406-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s88)-[GOOD] (assert s85)-Fast allSat, Looking for solution 2406-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 2407-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 2408-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 2409-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 2410-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 2411-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 2412-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 2413-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 2414-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 2415-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 2416-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 2417-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 2418-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s71)-[GOOD] (assert s84)-Fast allSat, Looking for solution 2418-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 2419-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 2420-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 2421-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 2422-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 2423-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 2424-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 2425-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 2426-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 2427-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 2428-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 2429-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 2430-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s70)-[GOOD] (assert s83)-Fast allSat, Looking for solution 2430-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 2431-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 2432-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 2433-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 2434-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 2435-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 2436-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 2437-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 2438-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 2439-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 2440-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 2441-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 2442-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s69)-[GOOD] (assert s82)-Fast allSat, Looking for solution 2442-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 2443-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 2444-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 2445-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 2446-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 2447-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 2448-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 2449-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 2450-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 2451-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 2452-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 2453-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 2454-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s68)-[GOOD] (assert s81)-Fast allSat, Looking for solution 2454-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 2455-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 2456-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 2457-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 2458-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 2459-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 2460-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 2461-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 2462-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 2463-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 2464-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 2465-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 2466-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s67)-[GOOD] (assert s80)-Fast allSat, Looking for solution 2466-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 2467-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 2468-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 2469-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 2470-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 2471-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 2472-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 2473-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 2474-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 2475-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 2476-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 2477-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 2478-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s67)-[GOOD] (assert s79)-Fast allSat, Looking for solution 2478-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 2479-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 2480-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 2481-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 2482-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 2483-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 2484-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 2485-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 2486-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 2487-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 2488-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 2489-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 2490-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s67)-[GOOD] (assert s78)-Fast allSat, Looking for solution 2490-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 2491-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 2492-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 2493-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 2494-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 2495-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 2496-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 2497-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 2498-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 2499-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 2500-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 2501-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 2502-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s67)-[GOOD] (assert s77)-Fast allSat, Looking for solution 2502-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 2503-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 2504-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 2505-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 2506-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 2507-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 2508-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 2509-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 2510-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 2511-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 2512-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 2513-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 2514-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s67)-[GOOD] (assert s76)-Fast allSat, Looking for solution 2514-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 2515-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 2516-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 2517-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 2518-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 2519-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 2520-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 2521-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 2522-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 2523-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 2524-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 2525-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 2526-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s67)-[GOOD] (assert s75)-Fast allSat, Looking for solution 2526-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 2527-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 2528-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 2529-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 2530-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 2531-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 2532-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 2533-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 2534-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 2535-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 2536-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 2537-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 2538-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s61)-[GOOD] (assert s101)-[GOOD] (assert s74)-Fast allSat, Looking for solution 2538-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 2539-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 2540-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 2541-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 2542-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 2543-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 2544-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 2545-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 2546-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 2547-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 2548-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 2549-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 2))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 2550-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s56)-[GOOD] (define-fun s102 () Bool (= s0 s3))-[GOOD] (assert s102)-Fast allSat, Looking for solution 2550-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s55)-Fast allSat, Looking for solution 2551-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s54)-Fast allSat, Looking for solution 2552-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s53)-Fast allSat, Looking for solution 2553-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s52)-Fast allSat, Looking for solution 2554-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s51)-Fast allSat, Looking for solution 2555-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s50)-Fast allSat, Looking for solution 2556-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s49)-Fast allSat, Looking for solution 2557-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s48)-Fast allSat, Looking for solution 2558-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s47)-Fast allSat, Looking for solution 2559-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s46)-Fast allSat, Looking for solution 2560-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s45)-Fast allSat, Looking for solution 2561-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s43)-Fast allSat, Looking for solution 2562-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s86)-Fast allSat, Looking for solution 2563-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s71)-[GOOD] (assert s89)-Fast allSat, Looking for solution 2563-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 2564-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 2565-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 2566-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 2567-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 2568-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 2569-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 2570-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 2571-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 2572-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 2573-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 2574-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 15))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 2575-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s88)-[GOOD] (assert s85)-Fast allSat, Looking for solution 2575-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 2576-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 2577-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 2578-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 2579-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 2580-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 2581-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 2582-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 2583-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 2584-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 2585-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 2586-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 14))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 2587-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s71)-[GOOD] (assert s84)-Fast allSat, Looking for solution 2587-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 2588-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 2589-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 2590-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 2591-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 2592-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 2593-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 2594-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 2595-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 2596-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 2597-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 2598-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 13))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 2599-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s70)-[GOOD] (assert s83)-Fast allSat, Looking for solution 2599-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 2600-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 2601-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 2602-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 2603-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 2604-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 2605-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 2606-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 2607-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 2608-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 2609-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 2610-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 12))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 2611-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s69)-[GOOD] (assert s82)-Fast allSat, Looking for solution 2611-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 2612-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 2613-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 2614-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 2615-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 2616-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 2617-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 2618-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 2619-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 2620-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 2621-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 2622-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 11))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 2623-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s68)-[GOOD] (assert s81)-Fast allSat, Looking for solution 2623-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 2624-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 2625-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 2626-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 2627-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 2628-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 2629-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 2630-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 2631-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 2632-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 2633-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 2634-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 10))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 2635-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s67)-[GOOD] (assert s80)-Fast allSat, Looking for solution 2635-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 2636-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 2637-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 2638-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 2639-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 2640-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 2641-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 2642-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 2643-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 2644-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 2645-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 2646-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 9))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 2647-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s66)-[GOOD] (assert s79)-Fast allSat, Looking for solution 2647-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 2648-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 2649-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 2650-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 2651-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 2652-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 2653-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 2654-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 2655-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 2656-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 2657-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 2658-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 8))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 2659-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s66)-[GOOD] (assert s78)-Fast allSat, Looking for solution 2659-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 2660-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 2661-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 2662-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 2663-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 2664-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 2665-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 2666-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 2667-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 2668-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 2669-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 2670-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 7))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 2671-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s66)-[GOOD] (assert s77)-Fast allSat, Looking for solution 2671-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 2672-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 2673-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 2674-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 2675-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 2676-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 2677-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 2678-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 2679-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 2680-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 2681-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 2682-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 6))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 2683-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s66)-[GOOD] (assert s76)-Fast allSat, Looking for solution 2683-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 2684-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 2685-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 2686-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 2687-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 2688-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 2689-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 2690-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 2691-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 2692-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 2693-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 2694-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 2695-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s66)-[GOOD] (assert s75)-Fast allSat, Looking for solution 2695-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 2696-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 2697-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 2698-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 2699-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 2700-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 2701-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 2702-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 2703-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 2704-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 2705-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 2706-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 2707-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s66)-[GOOD] (assert s74)-Fast allSat, Looking for solution 2707-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 2708-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 2709-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 2710-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 2711-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 2712-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 2713-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s88)-Fast allSat, Looking for solution 2714-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 2715-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 2716-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 2717-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 2718-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 2719-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s60)-[GOOD] (assert s102)-[GOOD] (assert s73)-Fast allSat, Looking for solution 2719-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 2720-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 2721-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 2722-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 2723-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 2724-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 2725-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 2726-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 2727-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 2728-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 1))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s70)+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 90+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 91+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 92+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 93+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 94+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 95+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 96+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 97+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 98+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 99+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 100+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 101+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s63)+[GOOD] (define-fun s78 () Bool (= s1 s26))+[GOOD] (assert s78)+Fast allSat, Looking for solution 101+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 102+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 103+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 104+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 105+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 106+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 107+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 108+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 109+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 110+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 111+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 112+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 113+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s64)+[GOOD] (define-fun s79 () Bool (= s1 s28))+[GOOD] (assert s79)+Fast allSat, Looking for solution 113+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 114+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 115+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 116+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 117+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 118+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 119+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 120+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 121+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 122+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 123+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 124+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 125+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s65)+[GOOD] (define-fun s80 () Bool (= s1 s30))+[GOOD] (assert s80)+Fast allSat, Looking for solution 125+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 126+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 127+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 128+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 129+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 130+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 131+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 132+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 133+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 134+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 135+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 136+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 137+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s66)+[GOOD] (define-fun s81 () Bool (= s1 s32))+[GOOD] (assert s81)+Fast allSat, Looking for solution 137+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 138+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 139+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 140+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 141+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 142+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 143+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 144+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 145+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 146+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 147+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 148+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 149+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s67)+[GOOD] (define-fun s82 () Bool (= s1 s34))+[GOOD] (assert s82)+Fast allSat, Looking for solution 149+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 150+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 151+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 152+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 153+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 154+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 155+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 156+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 157+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 158+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 159+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 160+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 161+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s68)+[GOOD] (define-fun s83 () Bool (= s1 s36))+[GOOD] (assert s83)+Fast allSat, Looking for solution 161+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 162+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 163+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 164+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 165+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 166+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 167+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 168+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 169+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 170+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 171+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 172+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 173+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s69)+[GOOD] (define-fun s84 () Bool (= s1 s38))+[GOOD] (assert s84)+Fast allSat, Looking for solution 173+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 174+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 175+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 176+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 177+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 178+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 179+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 180+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 181+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 182+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 183+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 184+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 185+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s70)+[GOOD] (assert s44)+[GOOD] (define-fun s85 () Bool (= s1 s40))+[GOOD] (assert s85)+Fast allSat, Looking for solution 185+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 186+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 187+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 188+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 189+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 190+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 191+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 192+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 193+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 194+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 195+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 196+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 197+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (define-fun s86 () Bool (distinct s1 s5))+[GOOD] (assert s86)+[GOOD] (define-fun s87 () Bool (= s0 s40))+[GOOD] (assert s87)+Fast allSat, Looking for solution 197+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s45)+Fast allSat, Looking for solution 198+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s46)+Fast allSat, Looking for solution 199+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s47)+Fast allSat, Looking for solution 200+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s48)+Fast allSat, Looking for solution 201+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s49)+Fast allSat, Looking for solution 202+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s50)+Fast allSat, Looking for solution 203+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s51)+Fast allSat, Looking for solution 204+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s52)+Fast allSat, Looking for solution 205+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s53)+Fast allSat, Looking for solution 206+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s54)+Fast allSat, Looking for solution 207+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s55)+Fast allSat, Looking for solution 208+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s56)+Fast allSat, Looking for solution 209+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s57)+Fast allSat, Looking for solution 210+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (define-fun s88 () Bool (distinct s2 s5))+[GOOD] (assert s88)+[GOOD] (assert s59)+Fast allSat, Looking for solution 210+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 211+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 212+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 213+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 214+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 215+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 216+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 217+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 218+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 219+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 220+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 221+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 222+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s73)+Fast allSat, Looking for solution 222+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 223+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 224+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 225+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 226+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 227+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 228+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 229+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 230+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 231+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 232+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 233+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 234+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s74)+Fast allSat, Looking for solution 234+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 235+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 236+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 237+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 238+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 239+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 240+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 241+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 242+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 243+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 244+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 245+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 246+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s75)+Fast allSat, Looking for solution 246+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 247+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 248+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 249+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 250+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 251+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 252+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 253+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 254+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 255+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 256+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 257+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 258+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s76)+Fast allSat, Looking for solution 258+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 259+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 260+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 261+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 262+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 263+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 264+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 265+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 266+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 267+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 268+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 269+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 270+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s77)+Fast allSat, Looking for solution 270+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 271+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 272+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 273+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 274+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 275+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 276+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 277+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 278+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 279+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 280+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 281+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 282+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s78)+Fast allSat, Looking for solution 282+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 283+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 284+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 285+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 286+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 287+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 288+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 289+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 290+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 291+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 292+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 293+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 294+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s79)+Fast allSat, Looking for solution 294+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 295+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 296+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 297+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 298+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 299+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 300+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 301+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 302+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 303+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 304+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 305+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 306+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s80)+Fast allSat, Looking for solution 306+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 307+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 308+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 309+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 310+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 311+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 312+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 313+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 314+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 315+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 316+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 317+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 318+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s81)+Fast allSat, Looking for solution 318+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 319+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 320+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 321+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 322+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 323+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 324+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 325+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 326+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 327+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 328+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 329+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 330+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s82)+Fast allSat, Looking for solution 330+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 331+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 332+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 333+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 334+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 335+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 336+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 337+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 338+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 339+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 340+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 341+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 342+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s83)+Fast allSat, Looking for solution 342+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 343+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 344+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 345+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 346+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 347+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 348+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 349+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 350+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 351+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 352+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 353+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 354+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s84)+Fast allSat, Looking for solution 354+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 355+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 356+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 357+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 358+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 359+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 360+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 361+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 362+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 363+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 364+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 365+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 366+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s70)+[GOOD] (assert s87)+[GOOD] (define-fun s89 () Bool (= s1 s5))+[GOOD] (assert s89)+Fast allSat, Looking for solution 366+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 367+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 368+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 369+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 370+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 371+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 372+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 373+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 374+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 375+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 376+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 377+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 14))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 378+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s43)+[GOOD] (define-fun s90 () Bool (= s0 s38))+[GOOD] (assert s90)+Fast allSat, Looking for solution 378+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s86)+Fast allSat, Looking for solution 379+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s46)+Fast allSat, Looking for solution 380+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s47)+Fast allSat, Looking for solution 381+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s48)+Fast allSat, Looking for solution 382+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s49)+Fast allSat, Looking for solution 383+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s50)+Fast allSat, Looking for solution 384+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s51)+Fast allSat, Looking for solution 385+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s52)+Fast allSat, Looking for solution 386+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s53)+Fast allSat, Looking for solution 387+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s54)+Fast allSat, Looking for solution 388+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s55)+Fast allSat, Looking for solution 389+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s56)+Fast allSat, Looking for solution 390+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s57)+Fast allSat, Looking for solution 391+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s58)+[GOOD] (assert s59)+Fast allSat, Looking for solution 391+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 392+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 393+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 394+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 395+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 396+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 397+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 398+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 399+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 400+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 401+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 402+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 403+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s73)+Fast allSat, Looking for solution 403+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 404+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 405+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 406+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 407+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 408+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 409+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 410+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 411+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 412+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 413+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 414+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 415+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s74)+Fast allSat, Looking for solution 415+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 416+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 417+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 418+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 419+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 420+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 421+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 422+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 423+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 424+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 425+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 426+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 427+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s75)+Fast allSat, Looking for solution 427+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 428+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 429+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 430+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 431+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 432+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 433+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 434+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 435+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 436+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 437+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 438+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 439+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s76)+Fast allSat, Looking for solution 439+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 440+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 441+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 442+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 443+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 444+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 445+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 446+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 447+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 448+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 449+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 450+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 451+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s77)+Fast allSat, Looking for solution 451+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 452+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 453+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 454+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 455+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 456+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 457+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 458+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 459+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 460+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 461+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 462+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 463+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s78)+Fast allSat, Looking for solution 463+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 464+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 465+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 466+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 467+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 468+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 469+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 470+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 471+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 472+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 473+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 474+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 475+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s79)+Fast allSat, Looking for solution 475+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 476+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 477+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 478+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 479+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 480+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 481+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 482+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 483+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 484+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 485+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 486+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 487+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s80)+Fast allSat, Looking for solution 487+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 488+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 489+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 490+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 491+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 492+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 493+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 494+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 495+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 496+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 497+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 498+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 499+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s81)+Fast allSat, Looking for solution 499+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 500+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 501+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 502+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 503+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 504+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 505+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 506+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 507+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 508+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 509+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 510+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 511+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s82)+Fast allSat, Looking for solution 511+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 512+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 513+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 514+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 515+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 516+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 517+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 518+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 519+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 520+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 521+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 522+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 523+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s83)+Fast allSat, Looking for solution 523+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 524+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 525+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 526+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 527+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 528+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 529+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 530+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 531+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 532+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 533+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 534+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 535+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s89)+Fast allSat, Looking for solution 535+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 536+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 537+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 538+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 539+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 540+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 541+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 542+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 543+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 544+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 545+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 546+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 547+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s88)+[GOOD] (assert s90)+[GOOD] (assert s85)+Fast allSat, Looking for solution 547+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 548+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 549+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 550+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 551+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 552+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 553+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 554+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 555+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 556+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 557+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 558+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 13))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 559+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s45)+[GOOD] (define-fun s91 () Bool (= s0 s36))+[GOOD] (assert s91)+Fast allSat, Looking for solution 559+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s43)+Fast allSat, Looking for solution 560+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s86)+Fast allSat, Looking for solution 561+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s47)+Fast allSat, Looking for solution 562+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s48)+Fast allSat, Looking for solution 563+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s49)+Fast allSat, Looking for solution 564+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s50)+Fast allSat, Looking for solution 565+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s51)+Fast allSat, Looking for solution 566+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s52)+Fast allSat, Looking for solution 567+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s53)+Fast allSat, Looking for solution 568+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s54)+Fast allSat, Looking for solution 569+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s55)+Fast allSat, Looking for solution 570+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s56)+Fast allSat, Looking for solution 571+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s57)+Fast allSat, Looking for solution 572+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s58)+[GOOD] (assert s59)+Fast allSat, Looking for solution 572+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 573+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 574+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 575+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 576+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 577+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 578+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 579+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 580+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 581+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 582+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 583+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 584+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s73)+Fast allSat, Looking for solution 584+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 585+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 586+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 587+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 588+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 589+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 590+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 591+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 592+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 593+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 594+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 595+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 596+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s58)+[GOOD] (assert s74)+Fast allSat, Looking for solution 596+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 597+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 598+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 599+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 600+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 601+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 602+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 603+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 604+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 605+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 606+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 607+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 608+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s60)+[GOOD] (assert s75)+Fast allSat, Looking for solution 608+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 609+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 610+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 611+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 612+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 613+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 614+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 615+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 616+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 617+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 618+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 619+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 620+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s61)+[GOOD] (assert s76)+Fast allSat, Looking for solution 620+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 621+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 622+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 623+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 624+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 625+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 626+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 627+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 628+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 629+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 630+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 631+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 632+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s62)+[GOOD] (assert s77)+Fast allSat, Looking for solution 632+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 633+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 634+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 635+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 636+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 637+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 638+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 639+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 640+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 641+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 642+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 643+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 644+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s63)+[GOOD] (assert s78)+Fast allSat, Looking for solution 644+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 645+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 646+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 647+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 648+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 649+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 650+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 651+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 652+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 653+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 654+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 655+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 656+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s64)+[GOOD] (assert s79)+Fast allSat, Looking for solution 656+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 657+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 658+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 659+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 660+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 661+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 662+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 663+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 664+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 665+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 666+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 667+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 668+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s65)+[GOOD] (assert s80)+Fast allSat, Looking for solution 668+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 669+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 670+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 671+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 672+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 673+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 674+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 675+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 676+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 677+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 678+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 679+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 680+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s66)+[GOOD] (assert s81)+Fast allSat, Looking for solution 680+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 681+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 682+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 683+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 684+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 685+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 686+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 687+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 688+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 689+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 690+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 691+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 692+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s67)+[GOOD] (assert s82)+Fast allSat, Looking for solution 692+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 693+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 694+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 695+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 696+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 697+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 698+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 699+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 700+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 701+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 702+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 703+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 704+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s68)+[GOOD] (assert s89)+Fast allSat, Looking for solution 704+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 705+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 706+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 707+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 708+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 709+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 710+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 711+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 712+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 713+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 714+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 715+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 716+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s68)+[GOOD] (assert s85)+Fast allSat, Looking for solution 716+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 717+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 718+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 719+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 720+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 721+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 722+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 723+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 724+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 725+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 726+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 727+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 728+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s71)+[GOOD] (assert s91)+[GOOD] (assert s84)+Fast allSat, Looking for solution 728+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 729+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 730+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 731+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 732+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 733+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 734+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 735+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 736+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 737+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 738+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 739+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 12))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 740+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s46)+[GOOD] (define-fun s92 () Bool (= s0 s34))+[GOOD] (assert s92)+Fast allSat, Looking for solution 740+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s57)+Fast allSat, Looking for solution 741+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s56)+Fast allSat, Looking for solution 742+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s55)+Fast allSat, Looking for solution 743+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s54)+Fast allSat, Looking for solution 744+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s53)+Fast allSat, Looking for solution 745+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s52)+Fast allSat, Looking for solution 746+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s51)+Fast allSat, Looking for solution 747+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s50)+Fast allSat, Looking for solution 748+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s49)+Fast allSat, Looking for solution 749+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s45)+Fast allSat, Looking for solution 750+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s43)+Fast allSat, Looking for solution 751+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s48)+Fast allSat, Looking for solution 752+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s86)+Fast allSat, Looking for solution 753+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s69)+[GOOD] (assert s89)+Fast allSat, Looking for solution 753+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 754+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 755+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 756+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 757+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 758+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 759+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 760+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 761+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 762+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 763+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 764+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 765+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s69)+[GOOD] (assert s81)+Fast allSat, Looking for solution 765+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 766+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 767+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 768+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 769+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 770+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 771+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 772+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 773+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 774+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 775+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 776+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 777+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s88)+[GOOD] (assert s85)+Fast allSat, Looking for solution 777+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 778+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 779+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 780+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 781+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 782+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 783+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 784+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 785+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 786+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 787+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 788+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 789+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s71)+[GOOD] (assert s84)+Fast allSat, Looking for solution 789+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 790+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 791+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 792+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 793+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 794+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 795+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 796+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 797+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 798+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 799+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 800+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 801+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s67)+[GOOD] (assert s80)+Fast allSat, Looking for solution 801+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 802+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 803+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 804+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 805+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 806+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 807+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 808+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 809+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 810+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 811+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 812+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 813+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s66)+[GOOD] (assert s79)+Fast allSat, Looking for solution 813+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 814+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 815+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 816+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 817+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 818+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 819+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 820+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 821+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 822+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 823+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 824+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 825+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s65)+[GOOD] (assert s78)+Fast allSat, Looking for solution 825+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 826+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 827+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 828+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 829+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 830+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 831+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 832+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 833+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 834+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 835+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 836+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 837+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s64)+[GOOD] (assert s77)+Fast allSat, Looking for solution 837+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 838+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 839+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 840+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 841+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 842+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 843+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 844+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 845+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 846+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 847+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 848+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 849+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s63)+[GOOD] (assert s76)+Fast allSat, Looking for solution 849+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 850+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 851+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 852+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 853+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 854+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 855+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 856+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 857+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 858+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 859+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 860+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 861+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s62)+[GOOD] (assert s75)+Fast allSat, Looking for solution 861+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 862+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 863+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 864+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 865+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 866+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 867+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 868+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 869+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 870+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 871+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 872+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 873+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s61)+[GOOD] (assert s74)+Fast allSat, Looking for solution 873+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 874+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 875+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 876+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 877+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 878+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 879+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 880+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 881+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 882+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 883+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 884+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 885+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s60)+[GOOD] (assert s73)+Fast allSat, Looking for solution 885+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 886+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 887+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 888+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 889+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 890+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 891+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 892+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 893+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 894+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 895+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 896+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 897+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s58)+[GOOD] (assert s59)+Fast allSat, Looking for solution 897+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 898+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 899+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 900+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 901+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 902+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 903+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 904+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 905+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 906+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 907+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 908+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 909+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s70)+[GOOD] (assert s92)+[GOOD] (assert s83)+Fast allSat, Looking for solution 909+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 910+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 911+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 912+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 913+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 914+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 915+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 916+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 917+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 918+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 919+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 920+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 11))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 921+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s47)+[GOOD] (define-fun s93 () Bool (= s0 s32))+[GOOD] (assert s93)+Fast allSat, Looking for solution 921+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s46)+Fast allSat, Looking for solution 922+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s45)+Fast allSat, Looking for solution 923+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s43)+Fast allSat, Looking for solution 924+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s86)+Fast allSat, Looking for solution 925+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s49)+Fast allSat, Looking for solution 926+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s50)+Fast allSat, Looking for solution 927+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s51)+Fast allSat, Looking for solution 928+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s52)+Fast allSat, Looking for solution 929+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s53)+Fast allSat, Looking for solution 930+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s54)+Fast allSat, Looking for solution 931+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s55)+Fast allSat, Looking for solution 932+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s56)+Fast allSat, Looking for solution 933+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s57)+Fast allSat, Looking for solution 934+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s58)+[GOOD] (assert s59)+Fast allSat, Looking for solution 934+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 935+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 936+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 937+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 938+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 939+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 940+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 941+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 942+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 943+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 944+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 945+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 946+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s73)+Fast allSat, Looking for solution 946+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 947+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 948+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 949+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 950+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 951+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 952+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 953+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 954+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 955+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 956+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 957+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 958+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s74)+Fast allSat, Looking for solution 958+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 959+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 960+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 961+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 962+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 963+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 964+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 965+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 966+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 967+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 968+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 969+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 970+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s75)+Fast allSat, Looking for solution 970+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 971+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 972+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 973+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 974+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 975+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 976+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 977+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 978+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 979+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 980+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 981+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 982+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s76)+Fast allSat, Looking for solution 982+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 983+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 984+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 985+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 986+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 987+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 988+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 989+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 990+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 991+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 992+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 993+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 994+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s77)+Fast allSat, Looking for solution 994+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 995+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 996+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 997+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 998+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 999+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1000+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1001+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1002+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1003+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1004+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1005+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1006+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s78)+Fast allSat, Looking for solution 1006+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 1007+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 1008+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1009+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1010+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1011+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1012+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1013+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1014+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1015+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1016+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1017+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1018+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s79)+Fast allSat, Looking for solution 1018+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 1019+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 1020+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 1021+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1022+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1023+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1024+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1025+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1026+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1027+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1028+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1029+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1030+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s80)+Fast allSat, Looking for solution 1030+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1031+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 1032+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 1033+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 1034+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1035+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1036+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1037+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1038+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1039+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1040+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1041+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1042+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s89)+Fast allSat, Looking for solution 1042+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1043+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1044+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 1045+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 1046+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 1047+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1048+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1049+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1050+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1051+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1052+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1053+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1054+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s85)+Fast allSat, Looking for solution 1054+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1055+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1056+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 1057+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 1058+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 1059+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1060+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1061+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1062+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1063+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1064+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1065+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1066+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s84)+Fast allSat, Looking for solution 1066+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1067+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1068+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 1069+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 1070+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 1071+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1072+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1073+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1074+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1075+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1076+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1077+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1078+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s83)+Fast allSat, Looking for solution 1078+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1079+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1080+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 1081+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 1082+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 1083+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1084+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1085+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1086+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1087+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1088+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1089+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1090+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s69)+[GOOD] (assert s93)+[GOOD] (assert s82)+Fast allSat, Looking for solution 1090+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1091+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1092+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 1093+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 1094+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 1095+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1096+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1097+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1098+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 1099+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1100+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1101+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 10))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1102+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s48)+[GOOD] (define-fun s94 () Bool (= s0 s30))+[GOOD] (assert s94)+Fast allSat, Looking for solution 1102+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s47)+Fast allSat, Looking for solution 1103+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s46)+Fast allSat, Looking for solution 1104+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s45)+Fast allSat, Looking for solution 1105+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s43)+Fast allSat, Looking for solution 1106+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s86)+Fast allSat, Looking for solution 1107+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s50)+Fast allSat, Looking for solution 1108+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s51)+Fast allSat, Looking for solution 1109+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s52)+Fast allSat, Looking for solution 1110+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s53)+Fast allSat, Looking for solution 1111+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s54)+Fast allSat, Looking for solution 1112+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s55)+Fast allSat, Looking for solution 1113+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s56)+Fast allSat, Looking for solution 1114+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s57)+Fast allSat, Looking for solution 1115+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s58)+[GOOD] (assert s59)+Fast allSat, Looking for solution 1115+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1116+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1117+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 1118+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 1119+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 1120+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1121+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1122+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1123+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1124+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1125+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1126+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1127+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s73)+Fast allSat, Looking for solution 1127+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1128+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 1129+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 1130+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 1131+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1132+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1133+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1134+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1135+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1136+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1137+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1138+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1139+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s58)+[GOOD] (assert s74)+Fast allSat, Looking for solution 1139+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1140+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1141+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1142+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1143+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1144+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1145+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 1146+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1147+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 1148+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 1149+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 1150+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1151+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s60)+[GOOD] (assert s75)+Fast allSat, Looking for solution 1151+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1152+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 1153+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 1154+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 1155+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1156+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1157+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1158+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1159+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1160+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1161+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1162+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 1163+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s61)+[GOOD] (assert s76)+Fast allSat, Looking for solution 1163+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 1164+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1165+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1166+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 1167+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 1168+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1169+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1170+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1171+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1172+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1173+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1174+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1175+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s62)+[GOOD] (assert s77)+Fast allSat, Looking for solution 1175+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1176+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1177+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1178+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 1179+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 1180+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1181+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1182+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1183+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1184+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1185+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1186+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1187+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s63)+[GOOD] (assert s78)+Fast allSat, Looking for solution 1187+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1188+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1189+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1190+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1191+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1192+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1193+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1194+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 1195+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1196+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1197+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1198+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 1199+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s64)+[GOOD] (assert s79)+Fast allSat, Looking for solution 1199+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 1200+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1201+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1202+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1203+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 1204+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 1205+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1206+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1207+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1208+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1209+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1210+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1211+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s65)+[GOOD] (assert s89)+Fast allSat, Looking for solution 1211+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1212+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1213+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 1214+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1215+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 1216+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 1217+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 1218+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1219+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1220+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1221+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1222+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1223+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s88)+[GOOD] (assert s85)+Fast allSat, Looking for solution 1223+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1224+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 1225+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 1226+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 1227+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1228+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1229+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1230+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 1231+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1232+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1233+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1234+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1235+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s71)+[GOOD] (assert s84)+Fast allSat, Looking for solution 1235+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1236+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 1237+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 1238+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 1239+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1240+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1241+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1242+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 1243+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1244+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1245+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1246+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1247+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s71)+[GOOD] (assert s83)+Fast allSat, Looking for solution 1247+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1248+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 1249+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 1250+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 1251+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1252+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1253+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1254+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 1255+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1256+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1257+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1258+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1259+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s71)+[GOOD] (assert s82)+Fast allSat, Looking for solution 1259+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1260+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 1261+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 1262+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 1263+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1264+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1265+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1266+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 1267+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1268+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1269+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1270+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1271+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s68)+[GOOD] (assert s94)+[GOOD] (assert s81)+Fast allSat, Looking for solution 1271+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1272+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 1273+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 1274+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 1275+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1276+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1277+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1278+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 1279+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1280+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1281+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1282+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 9))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1283+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s49)+[GOOD] (define-fun s95 () Bool (= s0 s28))+[GOOD] (assert s95)+Fast allSat, Looking for solution 1283+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s48)+Fast allSat, Looking for solution 1284+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s47)+Fast allSat, Looking for solution 1285+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s51)+Fast allSat, Looking for solution 1286+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s46)+Fast allSat, Looking for solution 1287+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s52)+Fast allSat, Looking for solution 1288+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s45)+Fast allSat, Looking for solution 1289+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s53)+Fast allSat, Looking for solution 1290+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s43)+Fast allSat, Looking for solution 1291+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s54)+Fast allSat, Looking for solution 1292+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s86)+Fast allSat, Looking for solution 1293+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s55)+Fast allSat, Looking for solution 1294+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s56)+Fast allSat, Looking for solution 1295+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s57)+Fast allSat, Looking for solution 1296+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s58)+[GOOD] (assert s59)+Fast allSat, Looking for solution 1296+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1297+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1298+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 1299+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 1300+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 1301+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1302+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1303+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1304+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1305+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1306+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1307+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1308+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s73)+Fast allSat, Looking for solution 1308+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 1309+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 1310+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 1311+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1312+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1313+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1314+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1315+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1316+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1317+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1318+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1319+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1320+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s58)+[GOOD] (assert s74)+Fast allSat, Looking for solution 1320+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 1321+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1322+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 1323+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 1324+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 1325+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1326+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1327+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1328+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1329+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1330+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1331+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1332+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s64)+[GOOD] (assert s89)+Fast allSat, Looking for solution 1332+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 1333+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 1334+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1335+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1336+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1337+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 1338+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1339+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1340+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1341+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1342+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1343+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1344+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s60)+[GOOD] (assert s75)+Fast allSat, Looking for solution 1344+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1345+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 1346+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 1347+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 1348+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 1349+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1350+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1351+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1352+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1353+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1354+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1355+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1356+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s64)+[GOOD] (assert s85)+Fast allSat, Looking for solution 1356+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1357+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1358+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1359+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1360+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1361+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1362+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 1363+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 1364+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1365+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1366+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1367+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 1368+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s61)+[GOOD] (assert s76)+Fast allSat, Looking for solution 1368+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 1369+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1370+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1371+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 1372+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 1373+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1374+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1375+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1376+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1377+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1378+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1379+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1380+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s64)+[GOOD] (assert s84)+Fast allSat, Looking for solution 1380+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 1381+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 1382+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1383+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1384+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1385+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 1386+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1387+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1388+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1389+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1390+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1391+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1392+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s62)+[GOOD] (assert s77)+Fast allSat, Looking for solution 1392+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1393+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1394+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1395+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 1396+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 1397+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1398+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1399+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1400+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1401+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1402+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1403+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1404+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s64)+[GOOD] (assert s83)+Fast allSat, Looking for solution 1404+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1405+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1406+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1407+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1408+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1409+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1410+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 1411+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 1412+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1413+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1414+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1415+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 1416+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s63)+[GOOD] (assert s78)+Fast allSat, Looking for solution 1416+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 1417+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1418+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1419+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1420+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 1421+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1422+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1423+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1424+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1425+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1426+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1427+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1428+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s64)+[GOOD] (assert s82)+Fast allSat, Looking for solution 1428+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 1429+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 1430+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1431+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1432+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1433+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 1434+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1435+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1436+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1437+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1438+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1439+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1440+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s64)+[GOOD] (assert s81)+Fast allSat, Looking for solution 1440+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1441+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1442+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1443+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1444+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1445+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 1446+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 1447+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1448+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1449+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1450+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 1451+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1452+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s67)+[GOOD] (assert s95)+[GOOD] (assert s80)+Fast allSat, Looking for solution 1452+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 1453+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 1454+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 1455+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1456+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1457+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1458+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 1459+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1460+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1461+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1462+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1463+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 8))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1464+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s50)+[GOOD] (define-fun s96 () Bool (= s0 s26))+[GOOD] (assert s96)+Fast allSat, Looking for solution 1464+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s49)+Fast allSat, Looking for solution 1465+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s48)+Fast allSat, Looking for solution 1466+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s47)+Fast allSat, Looking for solution 1467+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s46)+Fast allSat, Looking for solution 1468+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s45)+Fast allSat, Looking for solution 1469+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s43)+Fast allSat, Looking for solution 1470+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s86)+Fast allSat, Looking for solution 1471+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s52)+Fast allSat, Looking for solution 1472+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s53)+Fast allSat, Looking for solution 1473+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s54)+Fast allSat, Looking for solution 1474+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s55)+Fast allSat, Looking for solution 1475+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s56)+Fast allSat, Looking for solution 1476+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s57)+Fast allSat, Looking for solution 1477+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s58)+[GOOD] (assert s59)+Fast allSat, Looking for solution 1477+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1478+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1479+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 1480+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 1481+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1482+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1483+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1484+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1485+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1486+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1487+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1488+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1489+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s73)+Fast allSat, Looking for solution 1489+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 1490+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 1491+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1492+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1493+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1494+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1495+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1496+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1497+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1498+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1499+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1500+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1501+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s58)+[GOOD] (assert s74)+Fast allSat, Looking for solution 1501+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1502+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1503+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1504+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1505+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1506+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1507+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1508+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1509+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 1510+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 1511+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1512+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 1513+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s60)+[GOOD] (assert s75)+Fast allSat, Looking for solution 1513+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1514+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 1515+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 1516+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 1517+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1518+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1519+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1520+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1521+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1522+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1523+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1524+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1525+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s61)+[GOOD] (assert s76)+Fast allSat, Looking for solution 1525+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1526+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1527+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1528+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1529+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1530+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1531+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1532+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1533+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 1534+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1535+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1536+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 1537+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s62)+[GOOD] (assert s77)+Fast allSat, Looking for solution 1537+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 1538+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1539+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1540+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1541+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1542+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1543+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1544+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1545+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1546+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1547+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1548+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1549+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s63)+[GOOD] (assert s89)+Fast allSat, Looking for solution 1549+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 1550+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1551+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1552+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1553+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 1554+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1555+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1556+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1557+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1558+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1559+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1560+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1561+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s88)+[GOOD] (assert s85)+Fast allSat, Looking for solution 1561+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1562+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1563+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1564+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1565+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1566+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1567+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 1568+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 1569+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1570+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1571+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1572+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 1573+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s71)+[GOOD] (assert s84)+Fast allSat, Looking for solution 1573+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 1574+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1575+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1576+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1577+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 1578+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 1579+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1580+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1581+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1582+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1583+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1584+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1585+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s70)+[GOOD] (assert s83)+Fast allSat, Looking for solution 1585+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1586+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 1587+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1588+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1589+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 1590+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 1591+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1592+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1593+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1594+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1595+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1596+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1597+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s70)+[GOOD] (assert s82)+Fast allSat, Looking for solution 1597+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1598+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1599+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 1600+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1601+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 1602+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 1603+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1604+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1605+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1606+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1607+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1608+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1609+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s70)+[GOOD] (assert s81)+Fast allSat, Looking for solution 1609+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 1610+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 1611+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1612+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1613+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1614+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 1615+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1616+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1617+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1618+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1619+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1620+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1621+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s70)+[GOOD] (assert s80)+Fast allSat, Looking for solution 1621+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1622+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 1623+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 1624+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1625+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1626+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1627+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 1628+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1629+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1630+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1631+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1632+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1633+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s66)+[GOOD] (assert s96)+[GOOD] (assert s79)+Fast allSat, Looking for solution 1633+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1634+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1635+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1636+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1637+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1638+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1639+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 1640+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 1641+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1642+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1643+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1644+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 7))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 1645+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s51)+[GOOD] (define-fun s97 () Bool (= s0 s24))+[GOOD] (assert s97)+Fast allSat, Looking for solution 1645+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s50)+Fast allSat, Looking for solution 1646+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s49)+Fast allSat, Looking for solution 1647+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s48)+Fast allSat, Looking for solution 1648+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s47)+Fast allSat, Looking for solution 1649+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s46)+Fast allSat, Looking for solution 1650+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s45)+Fast allSat, Looking for solution 1651+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s43)+Fast allSat, Looking for solution 1652+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s86)+Fast allSat, Looking for solution 1653+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s53)+Fast allSat, Looking for solution 1654+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s54)+Fast allSat, Looking for solution 1655+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s55)+Fast allSat, Looking for solution 1656+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s56)+Fast allSat, Looking for solution 1657+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s57)+Fast allSat, Looking for solution 1658+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s58)+[GOOD] (assert s59)+Fast allSat, Looking for solution 1658+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 1659+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1660+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1661+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1662+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1663+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1664+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1665+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1666+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1667+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 1668+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1669+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1670+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s73)+Fast allSat, Looking for solution 1670+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 1671+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1672+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1673+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 1674+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1675+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1676+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1677+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1678+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1679+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1680+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1681+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1682+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s74)+Fast allSat, Looking for solution 1682+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1683+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1684+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1685+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1686+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 1687+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1688+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1689+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1690+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1691+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1692+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1693+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 1694+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s75)+Fast allSat, Looking for solution 1694+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1695+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1696+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 1697+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 1698+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1699+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1700+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1701+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1702+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1703+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1704+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1705+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1706+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s76)+Fast allSat, Looking for solution 1706+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1707+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1708+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1709+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 1710+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1711+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1712+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1713+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1714+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1715+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1716+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1717+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1718+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s89)+Fast allSat, Looking for solution 1718+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 1719+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1720+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1721+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1722+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 1723+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1724+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1725+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1726+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1727+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1728+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1729+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1730+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s85)+Fast allSat, Looking for solution 1730+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 1731+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1732+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1733+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1734+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 1735+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1736+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1737+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1738+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1739+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1740+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1741+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1742+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s84)+Fast allSat, Looking for solution 1742+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 1743+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1744+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1745+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1746+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 1747+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1748+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1749+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1750+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1751+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1752+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1753+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1754+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s83)+Fast allSat, Looking for solution 1754+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 1755+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1756+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1757+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1758+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 1759+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1760+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1761+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1762+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1763+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1764+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1765+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1766+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s82)+Fast allSat, Looking for solution 1766+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 1767+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1768+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1769+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1770+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 1771+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1772+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1773+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1774+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1775+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1776+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1777+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1778+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s81)+Fast allSat, Looking for solution 1778+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 1779+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1780+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1781+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1782+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 1783+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1784+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1785+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1786+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1787+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1788+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1789+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1790+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s80)+Fast allSat, Looking for solution 1790+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 1791+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1792+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1793+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1794+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 1795+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1796+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1797+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1798+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1799+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1800+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1801+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1802+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s79)+Fast allSat, Looking for solution 1802+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 1803+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1804+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1805+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1806+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 1807+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1808+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1809+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1810+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1811+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1812+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1813+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1814+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s65)+[GOOD] (assert s97)+[GOOD] (assert s78)+Fast allSat, Looking for solution 1814+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 1815+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1816+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1817+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1818+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 1819+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1820+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1821+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1822+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1823+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1824+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1825+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 6))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1826+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s52)+[GOOD] (define-fun s98 () Bool (= s0 s22))+[GOOD] (assert s98)+Fast allSat, Looking for solution 1826+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s51)+Fast allSat, Looking for solution 1827+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s50)+Fast allSat, Looking for solution 1828+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s49)+Fast allSat, Looking for solution 1829+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s48)+Fast allSat, Looking for solution 1830+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s47)+Fast allSat, Looking for solution 1831+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s46)+Fast allSat, Looking for solution 1832+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s45)+Fast allSat, Looking for solution 1833+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s43)+Fast allSat, Looking for solution 1834+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s86)+Fast allSat, Looking for solution 1835+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s54)+Fast allSat, Looking for solution 1836+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s55)+Fast allSat, Looking for solution 1837+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s56)+Fast allSat, Looking for solution 1838+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s57)+Fast allSat, Looking for solution 1839+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s58)+[GOOD] (assert s59)+Fast allSat, Looking for solution 1839+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 1840+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 1841+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1842+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1843+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1844+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1845+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1846+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1847+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1848+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1849+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1850+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1851+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s73)+Fast allSat, Looking for solution 1851+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1852+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1853+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 1854+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 1855+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1856+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1857+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1858+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1859+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1860+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1861+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1862+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1863+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s58)+[GOOD] (assert s74)+Fast allSat, Looking for solution 1863+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1864+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1865+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1866+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 1867+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 1868+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1869+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1870+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1871+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1872+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1873+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 1874+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1875+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s60)+[GOOD] (assert s75)+Fast allSat, Looking for solution 1875+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1876+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 1877+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 1878+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 1879+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1880+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1881+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1882+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1883+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1884+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1885+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1886+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1887+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s61)+[GOOD] (assert s89)+Fast allSat, Looking for solution 1887+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1888+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 1889+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 1890+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1891+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1892+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1893+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1894+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1895+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1896+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1897+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1898+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 1899+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s88)+[GOOD] (assert s85)+Fast allSat, Looking for solution 1899+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1900+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1901+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1902+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1903+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 1904+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 1905+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1906+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1907+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1908+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1909+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1910+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 1911+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s71)+[GOOD] (assert s84)+Fast allSat, Looking for solution 1911+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 1912+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1913+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1914+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1915+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 1916+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 1917+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1918+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1919+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1920+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1921+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1922+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1923+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s70)+[GOOD] (assert s83)+Fast allSat, Looking for solution 1923+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1924+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1925+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1926+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 1927+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 1928+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 1929+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1930+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1931+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1932+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1933+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1934+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1935+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s69)+[GOOD] (assert s82)+Fast allSat, Looking for solution 1935+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1936+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1937+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1938+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 1939+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 1940+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1941+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1942+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1943+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1944+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1945+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1946+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 1947+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s68)+[GOOD] (assert s81)+Fast allSat, Looking for solution 1947+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1948+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1949+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1950+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1951+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1952+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1953+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1954+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 1955+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 1956+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 1957+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1958+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1959+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s67)+[GOOD] (assert s80)+Fast allSat, Looking for solution 1959+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1960+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 1961+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 1962+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1963+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1964+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1965+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1966+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1967+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1968+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1969+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1970+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 1971+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s67)+[GOOD] (assert s79)+Fast allSat, Looking for solution 1971+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1972+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1973+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1974+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 1975+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 1976+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 1977+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1978+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1979+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1980+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1981+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1982+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1983+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s67)+[GOOD] (assert s78)+Fast allSat, Looking for solution 1983+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 1984+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1985+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1986+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1987+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1988+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1989+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 1990+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1991+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1992+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1993+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1994+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 1995+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s64)+[GOOD] (assert s98)+[GOOD] (assert s77)+Fast allSat, Looking for solution 1995+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1996+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1997+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1998+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1999+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 2000+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 2001+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 2002+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 2003+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 2004+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 2005+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 2006+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 2007+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s53)+[GOOD] (define-fun s99 () Bool (= s0 s20))+[GOOD] (assert s99)+Fast allSat, Looking for solution 2007+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s52)+Fast allSat, Looking for solution 2008+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s51)+Fast allSat, Looking for solution 2009+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s50)+Fast allSat, Looking for solution 2010+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s49)+Fast allSat, Looking for solution 2011+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s48)+Fast allSat, Looking for solution 2012+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s47)+Fast allSat, Looking for solution 2013+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s46)+Fast allSat, Looking for solution 2014+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s45)+Fast allSat, Looking for solution 2015+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s43)+Fast allSat, Looking for solution 2016+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s86)+Fast allSat, Looking for solution 2017+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s55)+Fast allSat, Looking for solution 2018+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s56)+Fast allSat, Looking for solution 2019+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s57)+Fast allSat, Looking for solution 2020+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s62)+[GOOD] (assert s59)+Fast allSat, Looking for solution 2020+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 2021+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 2022+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 2023+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 2024+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 2025+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 2026+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 2027+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 2028+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 2029+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 2030+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 2031+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 2032+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s62)+[GOOD] (assert s73)+Fast allSat, Looking for solution 2032+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 2033+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 2034+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 2035+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 2036+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 2037+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 2038+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 2039+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 2040+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 2041+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 2042+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 2043+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 2044+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s62)+[GOOD] (assert s74)+Fast allSat, Looking for solution 2044+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 2045+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 2046+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 2047+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 2048+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 2049+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 2050+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 2051+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 2052+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 2053+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 2054+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 2055+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 2056+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s71)+[GOOD] (assert s89)+Fast allSat, Looking for solution 2056+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 2057+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 2058+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 2059+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 2060+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 2061+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 2062+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 2063+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 2064+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 2065+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 2066+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 2067+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 2068+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s70)+[GOOD] (assert s85)+Fast allSat, Looking for solution 2068+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 2069+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 2070+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 2071+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 2072+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 2073+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 2074+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 2075+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 2076+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 2077+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 2078+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 2079+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 2080+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s69)+[GOOD] (assert s84)+Fast allSat, Looking for solution 2080+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 2081+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 2082+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 2083+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 2084+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 2085+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 2086+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 2087+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 2088+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 2089+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 2090+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 2091+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 2092+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s68)+[GOOD] (assert s83)+Fast allSat, Looking for solution 2092+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 2093+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 2094+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 2095+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 2096+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 2097+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 2098+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 2099+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 2100+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 2101+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 2102+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 2103+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 2104+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s67)+[GOOD] (assert s82)+Fast allSat, Looking for solution 2104+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 2105+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 2106+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 2107+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 2108+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 2109+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 2110+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 2111+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 2112+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 2113+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 2114+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 2115+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 2116+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s66)+[GOOD] (assert s81)+Fast allSat, Looking for solution 2116+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 2117+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 2118+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 2119+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 2120+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 2121+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 2122+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 2123+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 2124+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 2125+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 2126+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 2127+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 2128+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s65)+[GOOD] (assert s80)+Fast allSat, Looking for solution 2128+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 2129+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 2130+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 2131+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 2132+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 2133+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 2134+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 2135+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 2136+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 2137+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 2138+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 2139+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 2140+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s64)+[GOOD] (assert s79)+Fast allSat, Looking for solution 2140+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 2141+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 2142+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 2143+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 2144+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 2145+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 2146+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 2147+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 2148+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 2149+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 2150+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 2151+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 2152+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s63)+[GOOD] (assert s78)+Fast allSat, Looking for solution 2152+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 2153+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 2154+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 2155+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 2156+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 2157+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 2158+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 2159+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 2160+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 2161+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 2162+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 2163+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 2164+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s62)+[GOOD] (assert s77)+Fast allSat, Looking for solution 2164+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 2165+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 2166+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 2167+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 2168+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 2169+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 2170+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 2171+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 2172+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 2173+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 2174+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 2175+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 2176+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s63)+[GOOD] (assert s99)+[GOOD] (assert s76)+Fast allSat, Looking for solution 2176+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 2177+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 2178+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 2179+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 2180+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 2181+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 2182+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 2183+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 2184+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 2185+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 2186+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 2187+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 4))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 2188+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s54)+[GOOD] (define-fun s100 () Bool (= s0 s18))+[GOOD] (assert s100)+Fast allSat, Looking for solution 2188+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s53)+Fast allSat, Looking for solution 2189+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s52)+Fast allSat, Looking for solution 2190+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s51)+Fast allSat, Looking for solution 2191+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s50)+Fast allSat, Looking for solution 2192+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s49)+Fast allSat, Looking for solution 2193+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s48)+Fast allSat, Looking for solution 2194+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s47)+Fast allSat, Looking for solution 2195+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s46)+Fast allSat, Looking for solution 2196+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s45)+Fast allSat, Looking for solution 2197+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s43)+Fast allSat, Looking for solution 2198+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s86)+Fast allSat, Looking for solution 2199+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s56)+Fast allSat, Looking for solution 2200+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s57)+Fast allSat, Looking for solution 2201+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s58)+[GOOD] (assert s59)+Fast allSat, Looking for solution 2201+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 2202+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 2203+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 2204+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 2205+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 2206+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 2207+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 2208+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 2209+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 2210+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 2211+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 2212+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 2213+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s73)+Fast allSat, Looking for solution 2213+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 2214+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 2215+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 2216+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 2217+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 2218+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 2219+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 2220+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 2221+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 2222+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 2223+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 2224+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 2225+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s89)+Fast allSat, Looking for solution 2225+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 2226+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 2227+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 2228+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 2229+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 2230+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 2231+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 2232+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 2233+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 2234+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 2235+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 2236+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 2237+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s85)+Fast allSat, Looking for solution 2237+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 2238+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 2239+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 2240+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 2241+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 2242+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 2243+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 2244+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 2245+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 2246+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 2247+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 2248+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 2249+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s84)+Fast allSat, Looking for solution 2249+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 2250+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 2251+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 2252+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 2253+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 2254+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 2255+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 2256+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 2257+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 2258+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 2259+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 2260+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 2261+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s83)+Fast allSat, Looking for solution 2261+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 2262+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 2263+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 2264+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 2265+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 2266+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 2267+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 2268+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 2269+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 2270+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 2271+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 2272+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 2273+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s82)+Fast allSat, Looking for solution 2273+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 2274+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 2275+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 2276+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 2277+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 2278+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 2279+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 2280+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 2281+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 2282+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 2283+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 2284+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 2285+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s81)+Fast allSat, Looking for solution 2285+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 2286+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 2287+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 2288+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 2289+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 2290+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 2291+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 2292+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 2293+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 2294+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 2295+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 2296+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 2297+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s80)+Fast allSat, Looking for solution 2297+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 2298+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 2299+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 2300+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 2301+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 2302+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 2303+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 2304+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 2305+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 2306+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 2307+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 2308+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 2309+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s79)+Fast allSat, Looking for solution 2309+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 2310+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 2311+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 2312+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 2313+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 2314+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 2315+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 2316+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 2317+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 2318+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 2319+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 2320+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 2321+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s78)+Fast allSat, Looking for solution 2321+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 2322+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 2323+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 2324+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 2325+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 2326+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 2327+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 2328+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 2329+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 2330+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 2331+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 2332+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 2333+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s77)+Fast allSat, Looking for solution 2333+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 2334+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 2335+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 2336+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 2337+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 2338+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 2339+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 2340+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 2341+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 2342+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 2343+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 2344+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 2345+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s76)+Fast allSat, Looking for solution 2345+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 2346+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 2347+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 2348+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 2349+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 2350+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 2351+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 2352+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 2353+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 2354+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 2355+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 2356+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 2357+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s62)+[GOOD] (assert s100)+[GOOD] (assert s75)+Fast allSat, Looking for solution 2357+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 2358+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 2359+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 2360+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 2361+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 2362+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 2363+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 2364+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 2365+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 2366+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 2367+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 2368+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 3))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 2369+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s55)+[GOOD] (define-fun s101 () Bool (= s0 s16))+[GOOD] (assert s101)+Fast allSat, Looking for solution 2369+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s54)+Fast allSat, Looking for solution 2370+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s53)+Fast allSat, Looking for solution 2371+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s52)+Fast allSat, Looking for solution 2372+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s51)+Fast allSat, Looking for solution 2373+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s50)+Fast allSat, Looking for solution 2374+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s49)+Fast allSat, Looking for solution 2375+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s48)+Fast allSat, Looking for solution 2376+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s47)+Fast allSat, Looking for solution 2377+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s46)+Fast allSat, Looking for solution 2378+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s45)+Fast allSat, Looking for solution 2379+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s43)+Fast allSat, Looking for solution 2380+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s86)+Fast allSat, Looking for solution 2381+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s57)+Fast allSat, Looking for solution 2382+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s60)+[GOOD] (assert s59)+Fast allSat, Looking for solution 2382+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 2383+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 2384+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 2385+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 2386+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 2387+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 2388+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 2389+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 2390+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 2391+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 2392+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 2393+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 2394+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s71)+[GOOD] (assert s89)+Fast allSat, Looking for solution 2394+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 2395+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 2396+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 2397+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 2398+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 2399+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 2400+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 2401+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 2402+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 2403+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 2404+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 2405+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 2406+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s88)+[GOOD] (assert s85)+Fast allSat, Looking for solution 2406+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 2407+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 2408+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 2409+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 2410+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 2411+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 2412+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 2413+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 2414+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 2415+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 2416+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 2417+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 2418+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s71)+[GOOD] (assert s84)+Fast allSat, Looking for solution 2418+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 2419+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 2420+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 2421+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 2422+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 2423+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 2424+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 2425+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 2426+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 2427+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 2428+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 2429+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 2430+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s70)+[GOOD] (assert s83)+Fast allSat, Looking for solution 2430+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 2431+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 2432+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 2433+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 2434+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 2435+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 2436+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 2437+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 2438+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 2439+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 2440+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 2441+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 2442+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s69)+[GOOD] (assert s82)+Fast allSat, Looking for solution 2442+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 2443+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 2444+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 2445+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 2446+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 2447+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 2448+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 2449+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 2450+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 2451+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 2452+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 2453+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 2454+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s68)+[GOOD] (assert s81)+Fast allSat, Looking for solution 2454+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 2455+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 2456+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 2457+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 2458+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 2459+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 2460+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 2461+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 2462+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 2463+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 2464+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 2465+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 2466+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s67)+[GOOD] (assert s80)+Fast allSat, Looking for solution 2466+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 2467+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 2468+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 2469+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 2470+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 2471+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 2472+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 2473+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 2474+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 2475+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 2476+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 2477+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 2478+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s66)+[GOOD] (assert s79)+Fast allSat, Looking for solution 2478+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 2479+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 2480+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 2481+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 2482+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 2483+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 2484+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 2485+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 2486+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 2487+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 2488+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 2489+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 2490+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s65)+[GOOD] (assert s78)+Fast allSat, Looking for solution 2490+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 2491+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 2492+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 2493+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 2494+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 2495+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 2496+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 2497+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 2498+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 2499+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 2500+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 2501+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 2502+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s64)+[GOOD] (assert s77)+Fast allSat, Looking for solution 2502+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 2503+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 2504+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 2505+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 2506+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 2507+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 2508+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 2509+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 2510+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 2511+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 2512+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 2513+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 2514+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s64)+[GOOD] (assert s76)+Fast allSat, Looking for solution 2514+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 2515+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 2516+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 2517+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 2518+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 2519+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 2520+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 2521+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 2522+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 2523+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 2524+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 2525+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 2526+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s64)+[GOOD] (assert s75)+Fast allSat, Looking for solution 2526+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 2527+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 2528+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 2529+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 2530+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 2531+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 2532+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 2533+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 2534+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 2535+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 2536+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 2537+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 2538+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s61)+[GOOD] (assert s101)+[GOOD] (assert s74)+Fast allSat, Looking for solution 2538+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 2539+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 2540+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 2541+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 2542+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 2543+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 2544+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 2545+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 2546+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 2547+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 2548+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 2549+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 2))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 2550+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s56)+[GOOD] (define-fun s102 () Bool (= s0 s3))+[GOOD] (assert s102)+Fast allSat, Looking for solution 2550+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s55)+Fast allSat, Looking for solution 2551+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s54)+Fast allSat, Looking for solution 2552+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s53)+Fast allSat, Looking for solution 2553+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s52)+Fast allSat, Looking for solution 2554+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s51)+Fast allSat, Looking for solution 2555+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s50)+Fast allSat, Looking for solution 2556+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s49)+Fast allSat, Looking for solution 2557+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s48)+Fast allSat, Looking for solution 2558+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s47)+Fast allSat, Looking for solution 2559+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s46)+Fast allSat, Looking for solution 2560+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s45)+Fast allSat, Looking for solution 2561+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s43)+Fast allSat, Looking for solution 2562+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s86)+Fast allSat, Looking for solution 2563+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s58)+[GOOD] (assert s89)+Fast allSat, Looking for solution 2563+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 2564+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 2565+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 2566+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 2567+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 2568+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 2569+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 2570+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 2571+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 2572+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 2573+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 2574+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 15))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 2575+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s58)+[GOOD] (assert s85)+Fast allSat, Looking for solution 2575+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 2576+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 2577+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 2578+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 2579+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 2580+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 2581+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 2582+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 2583+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 2584+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 2585+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 2586+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 14))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 2587+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s58)+[GOOD] (assert s84)+Fast allSat, Looking for solution 2587+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 2588+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 2589+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 2590+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 2591+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 2592+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 2593+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 2594+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 2595+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 2596+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 2597+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 2598+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 13))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 2599+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s58)+[GOOD] (assert s83)+Fast allSat, Looking for solution 2599+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 2600+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 2601+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 2602+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 2603+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 2604+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 2605+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 2606+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 2607+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 2608+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 2609+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 2610+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 12))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 2611+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s58)+[GOOD] (assert s82)+Fast allSat, Looking for solution 2611+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 2612+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 2613+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 2614+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 2615+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 2616+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 2617+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 2618+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 2619+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 2620+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 2621+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 2622+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 11))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 2623+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s58)+[GOOD] (assert s81)+Fast allSat, Looking for solution 2623+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 2624+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 2625+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 2626+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 2627+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 2628+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 2629+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 2630+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 2631+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 2632+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 2633+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 2634+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 10))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 2635+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s58)+[GOOD] (assert s80)+Fast allSat, Looking for solution 2635+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 2636+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 2637+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 2638+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 2639+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 2640+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 2641+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 2642+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 2643+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 2644+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 2645+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 2646+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 9))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 2647+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s58)+[GOOD] (assert s79)+Fast allSat, Looking for solution 2647+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 2648+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 2649+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 2650+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 2651+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 2652+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 2653+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 2654+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 2655+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 2656+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 2657+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 2658+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 8))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 2659+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s58)+[GOOD] (assert s78)+Fast allSat, Looking for solution 2659+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 2660+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 2661+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 2662+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 2663+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 2664+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 2665+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 2666+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 2667+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 2668+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 2669+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 2670+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 7))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 2671+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s58)+[GOOD] (assert s77)+Fast allSat, Looking for solution 2671+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 2672+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 2673+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 2674+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 2675+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 2676+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 2677+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 2678+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 2679+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 2680+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 2681+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 2682+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 6))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 2683+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s58)+[GOOD] (assert s76)+Fast allSat, Looking for solution 2683+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 2684+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 2685+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 2686+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 2687+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 2688+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 2689+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 2690+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 2691+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 2692+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 2693+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 2694+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 2695+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s58)+[GOOD] (assert s75)+Fast allSat, Looking for solution 2695+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 2696+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 2697+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 2698+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 2699+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 2700+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 2701+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 2702+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 2703+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 2704+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 2705+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 2706+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 2707+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s58)+[GOOD] (assert s74)+Fast allSat, Looking for solution 2707+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 2708+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 2709+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 2710+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 2711+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 2712+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 2713+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 2714+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 2715+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 2716+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 2717+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 2718+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s88)+Fast allSat, Looking for solution 2719+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s60)+[GOOD] (assert s102)+[GOOD] (assert s73)+Fast allSat, Looking for solution 2719+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 2720+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 2721+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 2722+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 2723+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 2724+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 2725+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 2726+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 2727+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 2728+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 1))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s61) Fast allSat, Looking for solution 2729 [SEND] (check-sat) [RECV] sat
SBVTestSuite/GoldFiles/barrelRotate_Left_Int16_Word16.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -80,9 +80,8 @@ [GOOD] (assert (not s37)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Left_Int16_Word32.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -80,9 +80,8 @@ [GOOD] (assert (not s37)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Left_Int16_Word64.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -80,9 +80,8 @@ [GOOD] (assert (not s37)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Left_Int16_Word8.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -80,9 +80,8 @@ [GOOD] (assert (not s37)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Left_Int32_Word16.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -116,9 +116,8 @@ [GOOD] (assert (not s57)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Left_Int32_Word32.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -116,9 +116,8 @@ [GOOD] (assert (not s57)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Left_Int32_Word64.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -116,9 +116,8 @@ [GOOD] (assert (not s57)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Left_Int32_Word8.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -116,9 +116,8 @@ [GOOD] (assert (not s57)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Left_Int64_Word16.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -184,9 +184,8 @@ [GOOD] (assert (not s93)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Left_Int64_Word32.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -184,9 +184,8 @@ [GOOD] (assert (not s93)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Left_Int64_Word64.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -184,9 +184,8 @@ [GOOD] (assert (not s93)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Left_Int64_Word8.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -184,9 +184,8 @@ [GOOD] (assert (not s93)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Left_Int8_Word16.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -60,9 +60,8 @@ [GOOD] (assert (not s25)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Left_Int8_Word32.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -60,9 +60,8 @@ [GOOD] (assert (not s25)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Left_Int8_Word64.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -60,9 +60,8 @@ [GOOD] (assert (not s25)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Left_Int8_Word8.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -60,9 +60,8 @@ [GOOD] (assert (not s25)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Left_Word16_Word16.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -80,9 +80,8 @@ [GOOD] (assert (not s37)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Left_Word16_Word32.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -80,9 +80,8 @@ [GOOD] (assert (not s37)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Left_Word16_Word64.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -80,9 +80,8 @@ [GOOD] (assert (not s37)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Left_Word16_Word8.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -80,9 +80,8 @@ [GOOD] (assert (not s37)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Left_Word32_Word16.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -116,9 +116,8 @@ [GOOD] (assert (not s57)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Left_Word32_Word32.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -116,9 +116,8 @@ [GOOD] (assert (not s57)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Left_Word32_Word64.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -116,9 +116,8 @@ [GOOD] (assert (not s57)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Left_Word32_Word8.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -116,9 +116,8 @@ [GOOD] (assert (not s57)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Left_Word64_Word16.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -184,9 +184,8 @@ [GOOD] (assert (not s93)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Left_Word64_Word32.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -184,9 +184,8 @@ [GOOD] (assert (not s93)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Left_Word64_Word64.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -184,9 +184,8 @@ [GOOD] (assert (not s93)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Left_Word64_Word8.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -184,9 +184,8 @@ [GOOD] (assert (not s93)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Left_Word8_Word16.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -60,9 +60,8 @@ [GOOD] (assert (not s25)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Left_Word8_Word32.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -60,9 +60,8 @@ [GOOD] (assert (not s25)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Left_Word8_Word64.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -60,9 +60,8 @@ [GOOD] (assert (not s25)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Left_Word8_Word8.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -60,9 +60,8 @@ [GOOD] (assert (not s25)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Right_Int16_Word16.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -80,9 +80,8 @@ [GOOD] (assert (not s37)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Right_Int16_Word32.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -80,9 +80,8 @@ [GOOD] (assert (not s37)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Right_Int16_Word64.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -80,9 +80,8 @@ [GOOD] (assert (not s37)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Right_Int16_Word8.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -80,9 +80,8 @@ [GOOD] (assert (not s37)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Right_Int32_Word16.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -116,9 +116,8 @@ [GOOD] (assert (not s57)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Right_Int32_Word32.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -116,9 +116,8 @@ [GOOD] (assert (not s57)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Right_Int32_Word64.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -116,9 +116,8 @@ [GOOD] (assert (not s57)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Right_Int32_Word8.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -116,9 +116,8 @@ [GOOD] (assert (not s57)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Right_Int64_Word16.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -184,9 +184,8 @@ [GOOD] (assert (not s93)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Right_Int64_Word32.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -184,9 +184,8 @@ [GOOD] (assert (not s93)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Right_Int64_Word64.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -184,9 +184,8 @@ [GOOD] (assert (not s93)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Right_Int64_Word8.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -184,9 +184,8 @@ [GOOD] (assert (not s93)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Right_Int8_Word16.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -60,9 +60,8 @@ [GOOD] (assert (not s25)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Right_Int8_Word32.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -60,9 +60,8 @@ [GOOD] (assert (not s25)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Right_Int8_Word64.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -60,9 +60,8 @@ [GOOD] (assert (not s25)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Right_Int8_Word8.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -60,9 +60,8 @@ [GOOD] (assert (not s25)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Right_Word16_Word16.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -80,9 +80,8 @@ [GOOD] (assert (not s37)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Right_Word16_Word32.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -80,9 +80,8 @@ [GOOD] (assert (not s37)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Right_Word16_Word64.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -80,9 +80,8 @@ [GOOD] (assert (not s37)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Right_Word16_Word8.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -80,9 +80,8 @@ [GOOD] (assert (not s37)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Right_Word32_Word16.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -116,9 +116,8 @@ [GOOD] (assert (not s57)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Right_Word32_Word32.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -116,9 +116,8 @@ [GOOD] (assert (not s57)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Right_Word32_Word64.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -116,9 +116,8 @@ [GOOD] (assert (not s57)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Right_Word32_Word8.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -116,9 +116,8 @@ [GOOD] (assert (not s57)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Right_Word64_Word16.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -184,9 +184,8 @@ [GOOD] (assert (not s93)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Right_Word64_Word32.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -184,9 +184,8 @@ [GOOD] (assert (not s93)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Right_Word64_Word64.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -184,9 +184,8 @@ [GOOD] (assert (not s93)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Right_Word64_Word8.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -184,9 +184,8 @@ [GOOD] (assert (not s93)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Right_Word8_Word16.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -60,9 +60,8 @@ [GOOD] (assert (not s25)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Right_Word8_Word32.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -60,9 +60,8 @@ [GOOD] (assert (not s25)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Right_Word8_Word64.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -60,9 +60,8 @@ [GOOD] (assert (not s25)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/barrelRotate_Right_Word8_Word8.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value+** Calling: cvc5 --lang smt --incremental --no-interactive --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -60,9 +60,8 @@ [GOOD] (assert (not s25)) [SEND] (check-sat) [RECV] unsat-*** Solver   : CVC4+*** Solver   : CVC5 *** Exit code: ExitSuccess-*** Std-out  :   FINAL: Q.E.D.
SBVTestSuite/GoldFiles/charConstr09.gold view
@@ -38,8 +38,8 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (s0))-[RECV] ((s0 (seq.unit (mkSBVTuple2 (mkSBVTuple2 "A" "A") (seq.unit 0)))))+[RECV] ((s0 (seq.unit (mkSBVTuple2 (mkSBVTuple2 "A" "A") (seq.unit 2))))) -MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [("x",[(('A','A'),[0])] :: [((Char, Char), [Integer])])], modelUIFuns = []}+MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [("x",[(('A','A'),[2])] :: [((Char, Char), [Integer])])], modelUIFuns = []} DONE.*** Solver   : Z3 *** Exit code: ExitSuccess
SBVTestSuite/GoldFiles/charConstr10.gold view
@@ -45,8 +45,8 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (s0))-[RECV] ((s0 (seq.unit (mkSBVTuple2 (mkSBVTuple2 "B" "B") (seq.unit 0)))))+[RECV] ((s0 (seq.unit (mkSBVTuple2 (mkSBVTuple2 "B" "B") (seq.unit 2))))) -MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [("x",[(('B','B'),[0])] :: [((Char, Char), [Integer])])], modelUIFuns = []}+MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [("x",[(('B','B'),[2])] :: [((Char, Char), [Integer])])], modelUIFuns = []} DONE.*** Solver   : Z3 *** Exit code: ExitSuccess
SBVTestSuite/GoldFiles/charConstr11.gold view
@@ -45,15 +45,15 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (s0))-[RECV] ((s0 2))+[RECV] ((s0 3)) [SEND] (get-value (s1)) [RECV] ((s1 "A")) [GOOD] (set-option :pp.max_depth      4294967295) [GOOD] (set-option :pp.min_alias_size 4294967295) [GOOD] (set-option :model.inline_def  true      ) [SEND] (get-value (cf4))-[RECV] ((cf4 ((as const Array) (seq.unit (mkSBVTuple2 (mkSBVTuple2 "A" "A") (seq.unit 0))))))+[RECV] ((cf4 ((as const Array) (seq.unit (mkSBVTuple2 (mkSBVTuple2 "A" "A") (seq.unit 2)))))) -MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [("x",2 :: Integer),("c",'A' :: Char)], modelUIFuns = [("cf4",(SInteger -> SChar -> [((SChar, SChar), [SInteger])],([],[(('A','A'),[0])] :: [((Char, Char), [Integer])])))]}+MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [("x",3 :: Integer),("c",'A' :: Char)], modelUIFuns = [("cf4",(SInteger -> SChar -> [((SChar, SChar), [SInteger])],([],[(('A','A'),[2])] :: [((Char, Char), [Integer])])))]} DONE.*** Solver   : Z3 *** Exit code: ExitSuccess
SBVTestSuite/GoldFiles/query1.gold view
@@ -79,7 +79,7 @@ [SEND] (get-info :reason-unknown) [RECV] (:reason-unknown "state of the most recent check-sat command is not known") [SEND] (get-info :version)-[RECV] (:version "4.8.13")+[RECV] (:version "4.8.17") [SEND] (get-info :status) [RECV] (:status sat) [GOOD] (define-fun s16 () Int 4)@@ -110,7 +110,7 @@ [SEND] (get-info :reason-unknown) [RECV] (:reason-unknown "unknown") [SEND] (get-info :version)-[RECV] (:version "4.8.13")+[RECV] (:version "4.8.17") [SEND] (get-info :memory) [RECV] unsupported [SEND] (get-info :time)
SBVTestSuite/GoldFiles/query_abc.gold view
@@ -52,3 +52,4 @@ [RECV] ((s1 #x1)) *** Solver   : ABC *** Exit code: ExitSuccess+*** Std-err  : Cmd warning: redefining '%graft'
SBVTestSuite/GoldFiles/set_uninterp1.gold view
@@ -66,9 +66,9 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (s0))-[RECV] ((s0 (store ((as const (Array E Bool)) false) B true)))+[RECV] ((s0 (store (store (store ((as const (Array E Bool)) false) B true) C true) A true))) [GOOD] (push 1)-[GOOD] (define-fun s10 () (Array E Bool) (store ((as const (Array E Bool)) false) B true))+[GOOD] (define-fun s10 () (Array E Bool) (store (store (store ((as const (Array E Bool)) false) C true) B true) A true)) [GOOD] (define-fun s11 () Bool (= s0 s10)) [GOOD] (define-fun s12 () Bool (not s11)) [GOOD] (assert s12)@@ -76,9 +76,9 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (s0))-[RECV] ((s0 (store ((as const (Array E Bool)) false) C true)))+[RECV] ((s0 (store (store ((as const (Array E Bool)) false) C true) A true))) [GOOD] (push 1)-[GOOD] (define-fun s13 () (Array E Bool) (store ((as const (Array E Bool)) false) C true))+[GOOD] (define-fun s13 () (Array E Bool) (store (store ((as const (Array E Bool)) false) C true) A true)) [GOOD] (define-fun s14 () Bool (= s0 s13)) [GOOD] (define-fun s15 () Bool (not s14)) [GOOD] (assert s15)@@ -86,9 +86,9 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (s0))-[RECV] ((s0 (store (store ((as const (Array E Bool)) false) B true) C true)))+[RECV] ((s0 (store ((as const (Array E Bool)) false) B true))) [GOOD] (push 1)-[GOOD] (define-fun s16 () (Array E Bool) (store (store ((as const (Array E Bool)) false) C true) B true))+[GOOD] (define-fun s16 () (Array E Bool) (store ((as const (Array E Bool)) false) B true)) [GOOD] (define-fun s17 () Bool (= s0 s16)) [GOOD] (define-fun s18 () Bool (not s17)) [GOOD] (assert s18)@@ -96,9 +96,9 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (s0))-[RECV] ((s0 (store (store ((as const (Array E Bool)) false) C true) A true)))+[RECV] ((s0 (store (store ((as const (Array E Bool)) false) B true) C true))) [GOOD] (push 1)-[GOOD] (define-fun s19 () (Array E Bool) (store (store ((as const (Array E Bool)) false) C true) A true))+[GOOD] (define-fun s19 () (Array E Bool) (store (store ((as const (Array E Bool)) false) C true) B true)) [GOOD] (define-fun s20 () Bool (= s0 s19)) [GOOD] (define-fun s21 () Bool (not s20)) [GOOD] (assert s21)@@ -106,9 +106,9 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (s0))-[RECV] ((s0 (store (store (store ((as const (Array E Bool)) false) B true) C true) A true)))+[RECV] ((s0 (store ((as const (Array E Bool)) false) C true))) [GOOD] (push 1)-[GOOD] (define-fun s22 () (Array E Bool) (store (store (store ((as const (Array E Bool)) false) C true) B true) A true))+[GOOD] (define-fun s22 () (Array E Bool) (store ((as const (Array E Bool)) false) C true)) [GOOD] (define-fun s23 () Bool (= s0 s22)) [GOOD] (define-fun s24 () Bool (not s23)) [GOOD] (assert s24)@@ -128,15 +128,15 @@  FINAL: Solution #1:-  s0 = {A,B,C} :: {E}+  s0 = {C} :: {E} Solution #2:-  s0 = {A,C} :: {E}-Solution #3:   s0 = {B,C} :: {E}+Solution #3:+  s0 = {B} :: {E} Solution #4:-  s0 = {C} :: {E}+  s0 = {A,C} :: {E} Solution #5:-  s0 = {B} :: {E}+  s0 = {A,B,C} :: {E} Solution #6:   s0 = {A,B} :: {E} Solution #7:
SBVTestSuite/GoldFiles/uiSat_test2.gold view
@@ -169,11 +169,10 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q2))-[RECV] ((q2 (store (store ((as const Array) true) true false false) true true false)))+[RECV] ((q2 (store ((as const Array) true) true false false))) [GOOD] (define-fun q2_model10 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 true) (= x!1 true)) false           (ite (and (= x!0 true) (= x!1 false)) false-          true))+          true)        ) [GOOD] (define-fun q2_model10_reject () Bool           (exists ((x!0 Bool) (x!1 Bool))@@ -185,10 +184,11 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q2))-[RECV] ((q2 (store ((as const Array) true) true false false)))+[RECV] ((q2 (store (store ((as const Array) true) true false false) true true false))) [GOOD] (define-fun q2_model11 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 true) (= x!1 true)) false           (ite (and (= x!0 true) (= x!1 false)) false-          true)+          true))        ) [GOOD] (define-fun q2_model11_reject () Bool           (exists ((x!0 Bool) (x!1 Bool))@@ -231,10 +231,10 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q2))-[RECV] ((q2 (store ((as const Array) false) false false true)))+[RECV] ((q2 (store ((as const Array) true) false true false))) [GOOD] (define-fun q2_model14 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 false) (= x!1 false)) true-          false)+          (ite (and (= x!0 false) (= x!1 true)) false+          true)        ) [GOOD] (define-fun q2_model14_reject () Bool           (exists ((x!0 Bool) (x!1 Bool))@@ -246,11 +246,11 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q2))-[RECV] ((q2 (store (store ((as const Array) false) false false true) true false true)))+[RECV] ((q2 (store (store ((as const Array) true) false true false) true true false))) [GOOD] (define-fun q2_model15 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 true) (= x!1 false)) true-          (ite (and (= x!0 false) (= x!1 false)) true-          false))+          (ite (and (= x!0 true) (= x!1 true)) false+          (ite (and (= x!0 false) (= x!1 true)) false+          true))        ) [GOOD] (define-fun q2_model15_reject () Bool           (exists ((x!0 Bool) (x!1 Bool))@@ -262,10 +262,10 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q2))-[RECV] ((q2 (store ((as const Array) true) false true false)))+[RECV] ((q2 (store ((as const Array) false) false false true))) [GOOD] (define-fun q2_model16 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 false) (= x!1 true)) false-          true)+          (ite (and (= x!0 false) (= x!1 false)) true+          false)        ) [GOOD] (define-fun q2_model16_reject () Bool           (exists ((x!0 Bool) (x!1 Bool))@@ -281,17 +281,17 @@  RESULT: Solution #1:   q2 :: Bool -> Bool -> Bool-  q2 False True = False-  q2 _     _    = True -Solution #2:-  q2 :: Bool -> Bool -> Bool-  q2 True  False = True    q2 False False = True    q2 _     _     = False+Solution #2:+  q2 :: Bool -> Bool -> Bool+  q2 True  True = False+  q2 False True = False+  q2 _     _    = True  Solution #3:   q2 :: Bool -> Bool -> Bool-  q2 False False = True -  q2 _     _     = False+  q2 False True = False+  q2 _     _    = True  Solution #4:   q2 :: Bool -> Bool -> Bool   q2 False True  = False@@ -303,11 +303,11 @@   q2 _    _    = True  Solution #6:   q2 :: Bool -> Bool -> Bool+  q2 True True  = False   q2 True False = False   q2 _    _     = True  Solution #7:   q2 :: Bool -> Bool -> Bool-  q2 True True  = False   q2 True False = False   q2 _    _     = True  Solution #8:
SBVTestSuite/GoldFiles/uiSat_test3.gold view
@@ -533,20 +533,20 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q1))-[RECV] ((q1 ((as const Array) false)))+[RECV] ((q1 (store ((as const Array) true) true false))) [SEND] (get-value (q2))-[RECV] ((q2 (store (store ((as const Array) true) false true false) true false false)))+[RECV] ((q2 (store ((as const Array) true) false true false))) [GOOD] (define-fun q1_model19 ((x!0 Bool)) Bool-          false+          (ite (and (= x!0 true)) false+          true)        ) [GOOD] (define-fun q1_model19_reject () Bool           (exists ((x!0 Bool))                   (distinct (q1         x!0)                             (q1_model19 x!0)))) [GOOD] (define-fun q2_model19 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 true) (= x!1 false)) false           (ite (and (= x!0 false) (= x!1 true)) false-          true))+          true)        ) [GOOD] (define-fun q2_model19_reject () Bool           (exists ((x!0 Bool) (x!1 Bool))@@ -561,11 +561,11 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q1))-[RECV] ((q1 ((as const Array) false)))+[RECV] ((q1 ((as const Array) true))) [SEND] (get-value (q2))-[RECV] ((q2 (store (store ((as const Array) true) true true false) false true false)))+[RECV] ((q2 (store ((as const Array) true) false true false))) [GOOD] (define-fun q1_model20 ((x!0 Bool)) Bool-          false+          true        ) [GOOD] (define-fun q1_model20_reject () Bool           (exists ((x!0 Bool))@@ -573,8 +573,7 @@                             (q1_model20 x!0)))) [GOOD] (define-fun q2_model20 ((x!0 Bool) (x!1 Bool)) Bool           (ite (and (= x!0 false) (= x!1 true)) false-          (ite (and (= x!0 true) (= x!1 true)) false-          true))+          true)        ) [GOOD] (define-fun q2_model20_reject () Bool           (exists ((x!0 Bool) (x!1 Bool))@@ -591,7 +590,7 @@ [SEND] (get-value (q1)) [RECV] ((q1 ((as const Array) true))) [SEND] (get-value (q2))-[RECV] ((q2 (store ((as const Array) true) false true false)))+[RECV] ((q2 (store ((as const Array) true) true true false))) [GOOD] (define-fun q1_model21 ((x!0 Bool)) Bool           true        )@@ -600,7 +599,7 @@                   (distinct (q1         x!0)                             (q1_model21 x!0)))) [GOOD] (define-fun q2_model21 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 false) (= x!1 true)) false+          (ite (and (= x!0 true) (= x!1 true)) false           true)        ) [GOOD] (define-fun q2_model21_reject () Bool@@ -618,7 +617,7 @@ [SEND] (get-value (q1)) [RECV] ((q1 ((as const Array) true))) [SEND] (get-value (q2))-[RECV] ((q2 (store (store ((as const Array) true) true true false) true false false)))+[RECV] ((q2 ((as const Array) true))) [GOOD] (define-fun q1_model22 ((x!0 Bool)) Bool           true        )@@ -627,9 +626,7 @@                   (distinct (q1         x!0)                             (q1_model22 x!0)))) [GOOD] (define-fun q2_model22 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 true) (= x!1 false)) false-          (ite (and (= x!0 true) (= x!1 true)) false-          true))+          true        ) [GOOD] (define-fun q2_model22_reject () Bool           (exists ((x!0 Bool) (x!1 Bool))@@ -644,21 +641,19 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q1))-[RECV] ((q1 (lambda ((x!1 Bool)) x!1)))+[RECV] ((q1 (store ((as const Array) true) true false))) [SEND] (get-value (q2))-[RECV] ((q2 (store (store ((as const Array) true) true true false) true false false)))+[RECV] ((q2 ((as const Array) true))) [GOOD] (define-fun q1_model23 ((x!0 Bool)) Bool-          (ite (and (= x!0 true)) true-          false)+          (ite (and (= x!0 true)) false+          true)        ) [GOOD] (define-fun q1_model23_reject () Bool           (exists ((x!0 Bool))                   (distinct (q1         x!0)                             (q1_model23 x!0)))) [GOOD] (define-fun q2_model23 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 true) (= x!1 false)) false-          (ite (and (= x!0 true) (= x!1 true)) false-          true))+          true        ) [GOOD] (define-fun q2_model23_reject () Bool           (exists ((x!0 Bool) (x!1 Bool))@@ -673,11 +668,12 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q1))-[RECV] ((q1 ((as const Array) false)))+[RECV] ((q1 (store ((as const Array) true) true false))) [SEND] (get-value (q2))-[RECV] ((q2 (store (store ((as const Array) true) true false false) true true false)))+[RECV] ((q2 (store ((as const Array) true) true true false))) [GOOD] (define-fun q1_model24 ((x!0 Bool)) Bool-          false+          (ite (and (= x!0 true)) false+          true)        ) [GOOD] (define-fun q1_model24_reject () Bool           (exists ((x!0 Bool))@@ -685,8 +681,7 @@                             (q1_model24 x!0)))) [GOOD] (define-fun q2_model24 ((x!0 Bool) (x!1 Bool)) Bool           (ite (and (= x!0 true) (= x!1 true)) false-          (ite (and (= x!0 true) (= x!1 false)) false-          true))+          true)        ) [GOOD] (define-fun q2_model24_reject () Bool           (exists ((x!0 Bool) (x!1 Bool))@@ -701,11 +696,11 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q1))-[RECV] ((q1 ((as const Array) false)))+[RECV] ((q1 ((as const Array) true))) [SEND] (get-value (q2)) [RECV] ((q2 (store ((as const Array) true) true false false))) [GOOD] (define-fun q1_model25 ((x!0 Bool)) Bool-          false+          true        ) [GOOD] (define-fun q1_model25_reject () Bool           (exists ((x!0 Bool))@@ -728,21 +723,20 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q1))-[RECV] ((q1 (store ((as const Array) false) false true)))+[RECV] ((q1 ((as const Array) true))) [SEND] (get-value (q2))-[RECV] ((q2 (store (store ((as const Array) true) true false false) true true false)))+[RECV] ((q2 (store (store ((as const Array) false) false false true) false true true))) [GOOD] (define-fun q1_model26 ((x!0 Bool)) Bool-          (ite (and (= x!0 false)) true-          false)+          true        ) [GOOD] (define-fun q1_model26_reject () Bool           (exists ((x!0 Bool))                   (distinct (q1         x!0)                             (q1_model26 x!0)))) [GOOD] (define-fun q2_model26 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 true) (= x!1 true)) false-          (ite (and (= x!0 true) (= x!1 false)) false-          true))+          (ite (and (= x!0 false) (= x!1 true)) true+          (ite (and (= x!0 false) (= x!1 false)) true+          false))        ) [GOOD] (define-fun q2_model26_reject () Bool           (exists ((x!0 Bool) (x!1 Bool))@@ -759,7 +753,7 @@ [SEND] (get-value (q1)) [RECV] ((q1 (lambda ((x!1 Bool)) x!1))) [SEND] (get-value (q2))-[RECV] ((q2 ((as const Array) false)))+[RECV] ((q2 (store (store ((as const Array) false) false false true) false true true))) [GOOD] (define-fun q1_model27 ((x!0 Bool)) Bool           (ite (and (= x!0 true)) true           false)@@ -769,7 +763,9 @@                   (distinct (q1         x!0)                             (q1_model27 x!0)))) [GOOD] (define-fun q2_model27 ((x!0 Bool) (x!1 Bool)) Bool-          false+          (ite (and (= x!0 false) (= x!1 true)) true+          (ite (and (= x!0 false) (= x!1 false)) true+          false))        ) [GOOD] (define-fun q2_model27_reject () Bool           (exists ((x!0 Bool) (x!1 Bool))@@ -786,7 +782,7 @@ [SEND] (get-value (q1)) [RECV] ((q1 (lambda ((x!1 Bool)) x!1))) [SEND] (get-value (q2))-[RECV] ((q2 (store ((as const Array) true) false false false)))+[RECV] ((q2 ((as const Array) false))) [GOOD] (define-fun q1_model28 ((x!0 Bool)) Bool           (ite (and (= x!0 true)) true           false)@@ -796,8 +792,7 @@                   (distinct (q1         x!0)                             (q1_model28 x!0)))) [GOOD] (define-fun q2_model28 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 false) (= x!1 false)) false-          true)+          false        ) [GOOD] (define-fun q2_model28_reject () Bool           (exists ((x!0 Bool) (x!1 Bool))@@ -842,7 +837,7 @@ [SEND] (get-value (q1)) [RECV] ((q1 (lambda ((x!1 Bool)) x!1))) [SEND] (get-value (q2))-[RECV] ((q2 (store (store ((as const Array) false) false true true) true false true)))+[RECV] ((q2 (store ((as const Array) true) false false false))) [GOOD] (define-fun q1_model30 ((x!0 Bool)) Bool           (ite (and (= x!0 true)) true           false)@@ -852,9 +847,8 @@                   (distinct (q1         x!0)                             (q1_model30 x!0)))) [GOOD] (define-fun q2_model30 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 true) (= x!1 false)) true-          (ite (and (= x!0 false) (= x!1 true)) true-          false))+          (ite (and (= x!0 false) (= x!1 false)) false+          true)        ) [GOOD] (define-fun q2_model30_reject () Bool           (exists ((x!0 Bool) (x!1 Bool))@@ -871,7 +865,7 @@ [SEND] (get-value (q1)) [RECV] ((q1 (lambda ((x!1 Bool)) x!1))) [SEND] (get-value (q2))-[RECV] ((q2 (store ((as const Array) false) true true true)))+[RECV] ((q2 (store ((as const Array) false) true false true))) [GOOD] (define-fun q1_model31 ((x!0 Bool)) Bool           (ite (and (= x!0 true)) true           false)@@ -881,7 +875,7 @@                   (distinct (q1         x!0)                             (q1_model31 x!0)))) [GOOD] (define-fun q2_model31 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 true) (= x!1 true)) true+          (ite (and (= x!0 true) (= x!1 false)) true           false)        ) [GOOD] (define-fun q2_model31_reject () Bool@@ -899,7 +893,7 @@ [SEND] (get-value (q1)) [RECV] ((q1 (lambda ((x!1 Bool)) x!1))) [SEND] (get-value (q2))-[RECV] ((q2 (store ((as const Array) false) true false true)))+[RECV] ((q2 (store (store ((as const Array) false) true false true) true true true))) [GOOD] (define-fun q1_model32 ((x!0 Bool)) Bool           (ite (and (= x!0 true)) true           false)@@ -909,8 +903,9 @@                   (distinct (q1         x!0)                             (q1_model32 x!0)))) [GOOD] (define-fun q2_model32 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 true) (= x!1 true)) true           (ite (and (= x!0 true) (= x!1 false)) true-          false)+          false))        ) [GOOD] (define-fun q2_model32_reject () Bool           (exists ((x!0 Bool) (x!1 Bool))@@ -927,7 +922,7 @@ [SEND] (get-value (q1)) [RECV] ((q1 ((as const Array) false))) [SEND] (get-value (q2))-[RECV] ((q2 (store ((as const Array) true) false false false)))+[RECV] ((q2 (store ((as const Array) false) true false true))) [GOOD] (define-fun q1_model33 ((x!0 Bool)) Bool           false        )@@ -936,8 +931,8 @@                   (distinct (q1         x!0)                             (q1_model33 x!0)))) [GOOD] (define-fun q2_model33 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 false) (= x!1 false)) false-          true)+          (ite (and (= x!0 true) (= x!1 false)) true+          false)        ) [GOOD] (define-fun q2_model33_reject () Bool           (exists ((x!0 Bool) (x!1 Bool))@@ -954,7 +949,7 @@ [SEND] (get-value (q1)) [RECV] ((q1 ((as const Array) false))) [SEND] (get-value (q2))-[RECV] ((q2 (store ((as const Array) false) true false true)))+[RECV] ((q2 (store (store ((as const Array) false) true false true) false true true))) [GOOD] (define-fun q1_model34 ((x!0 Bool)) Bool           false        )@@ -963,8 +958,9 @@                   (distinct (q1         x!0)                             (q1_model34 x!0)))) [GOOD] (define-fun q2_model34 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 false) (= x!1 true)) true           (ite (and (= x!0 true) (= x!1 false)) true-          false)+          false))        ) [GOOD] (define-fun q2_model34_reject () Bool           (exists ((x!0 Bool) (x!1 Bool))@@ -979,18 +975,19 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q1))-[RECV] ((q1 ((as const Array) false)))+[RECV] ((q1 (lambda ((x!1 Bool)) x!1))) [SEND] (get-value (q2))-[RECV] ((q2 (store (store ((as const Array) false) true false true) true true true)))+[RECV] ((q2 (store (store ((as const Array) false) true false true) false true true))) [GOOD] (define-fun q1_model35 ((x!0 Bool)) Bool-          false+          (ite (and (= x!0 true)) true+          false)        ) [GOOD] (define-fun q1_model35_reject () Bool           (exists ((x!0 Bool))                   (distinct (q1         x!0)                             (q1_model35 x!0)))) [GOOD] (define-fun q2_model35 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 true) (= x!1 true)) true+          (ite (and (= x!0 false) (= x!1 true)) true           (ite (and (= x!0 true) (= x!1 false)) true           false))        )@@ -1009,7 +1006,7 @@ [SEND] (get-value (q1)) [RECV] ((q1 (lambda ((x!1 Bool)) x!1))) [SEND] (get-value (q2))-[RECV] ((q2 (store (store ((as const Array) false) true false true) true true true)))+[RECV] ((q2 (store (store ((as const Array) false) true true true) false true true))) [GOOD] (define-fun q1_model36 ((x!0 Bool)) Bool           (ite (and (= x!0 true)) true           false)@@ -1019,8 +1016,8 @@                   (distinct (q1         x!0)                             (q1_model36 x!0)))) [GOOD] (define-fun q2_model36 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 false) (= x!1 true)) true           (ite (and (= x!0 true) (= x!1 true)) true-          (ite (and (= x!0 true) (= x!1 false)) true           false))        ) [GOOD] (define-fun q2_model36_reject () Bool@@ -1038,7 +1035,7 @@ [SEND] (get-value (q1)) [RECV] ((q1 (lambda ((x!1 Bool)) x!1))) [SEND] (get-value (q2))-[RECV] ((q2 (store (store ((as const Array) false) true true true) false true true)))+[RECV] ((q2 (store ((as const Array) false) true true true))) [GOOD] (define-fun q1_model37 ((x!0 Bool)) Bool           (ite (and (= x!0 true)) true           false)@@ -1048,9 +1045,8 @@                   (distinct (q1         x!0)                             (q1_model37 x!0)))) [GOOD] (define-fun q2_model37 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 false) (= x!1 true)) true           (ite (and (= x!0 true) (= x!1 true)) true-          false))+          false)        ) [GOOD] (define-fun q2_model37_reject () Bool           (exists ((x!0 Bool) (x!1 Bool))@@ -1065,19 +1061,20 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q1))-[RECV] ((q1 ((as const Array) false)))+[RECV] ((q1 (store ((as const Array) false) false true))) [SEND] (get-value (q2))-[RECV] ((q2 (store (store ((as const Array) false) true true true) false true true)))+[RECV] ((q2 (store (store ((as const Array) false) false true true) false false true))) [GOOD] (define-fun q1_model38 ((x!0 Bool)) Bool-          false+          (ite (and (= x!0 false)) true+          false)        ) [GOOD] (define-fun q1_model38_reject () Bool           (exists ((x!0 Bool))                   (distinct (q1         x!0)                             (q1_model38 x!0)))) [GOOD] (define-fun q2_model38 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 false) (= x!1 false)) true           (ite (and (= x!0 false) (= x!1 true)) true-          (ite (and (= x!0 true) (= x!1 true)) true           false))        ) [GOOD] (define-fun q2_model38_reject () Bool@@ -1093,19 +1090,20 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q1))-[RECV] ((q1 ((as const Array) false)))+[RECV] ((q1 (store ((as const Array) false) false true))) [SEND] (get-value (q2))-[RECV] ((q2 (store ((as const Array) false) false true true)))+[RECV] ((q2 (store ((as const Array) true) true false false))) [GOOD] (define-fun q1_model39 ((x!0 Bool)) Bool-          false+          (ite (and (= x!0 false)) true+          false)        ) [GOOD] (define-fun q1_model39_reject () Bool           (exists ((x!0 Bool))                   (distinct (q1         x!0)                             (q1_model39 x!0)))) [GOOD] (define-fun q2_model39 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 false) (= x!1 true)) true-          false)+          (ite (and (= x!0 true) (= x!1 false)) false+          true)        ) [GOOD] (define-fun q2_model39_reject () Bool           (exists ((x!0 Bool) (x!1 Bool))@@ -1120,20 +1118,20 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q1))-[RECV] ((q1 (store ((as const Array) false) false true)))+[RECV] ((q1 ((as const Array) false))) [SEND] (get-value (q2))-[RECV] ((q2 (store ((as const Array) false) false true true)))+[RECV] ((q2 (store (store ((as const Array) true) true false false) false false false))) [GOOD] (define-fun q1_model40 ((x!0 Bool)) Bool-          (ite (and (= x!0 false)) true-          false)+          false        ) [GOOD] (define-fun q1_model40_reject () Bool           (exists ((x!0 Bool))                   (distinct (q1         x!0)                             (q1_model40 x!0)))) [GOOD] (define-fun q2_model40 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 false) (= x!1 true)) true-          false)+          (ite (and (= x!0 false) (= x!1 false)) false+          (ite (and (= x!0 true) (= x!1 false)) false+          true))        ) [GOOD] (define-fun q2_model40_reject () Bool           (exists ((x!0 Bool) (x!1 Bool))@@ -1148,21 +1146,19 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q1))-[RECV] ((q1 (store ((as const Array) false) false true)))+[RECV] ((q1 ((as const Array) false))) [SEND] (get-value (q2))-[RECV] ((q2 (store (store ((as const Array) false) false true true) true true true)))+[RECV] ((q2 (store ((as const Array) false) false true true))) [GOOD] (define-fun q1_model41 ((x!0 Bool)) Bool-          (ite (and (= x!0 false)) true-          false)+          false        ) [GOOD] (define-fun q1_model41_reject () Bool           (exists ((x!0 Bool))                   (distinct (q1         x!0)                             (q1_model41 x!0)))) [GOOD] (define-fun q2_model41 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 true) (= x!1 true)) true           (ite (and (= x!0 false) (= x!1 true)) true-          false))+          false)        ) [GOOD] (define-fun q2_model41_reject () Bool           (exists ((x!0 Bool) (x!1 Bool))@@ -1177,19 +1173,20 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q1))-[RECV] ((q1 ((as const Array) true)))+[RECV] ((q1 ((as const Array) false))) [SEND] (get-value (q2))-[RECV] ((q2 (store ((as const Array) false) false true true)))+[RECV] ((q2 (store (store ((as const Array) true) false false false) false true false))) [GOOD] (define-fun q1_model42 ((x!0 Bool)) Bool-          true+          false        ) [GOOD] (define-fun q1_model42_reject () Bool           (exists ((x!0 Bool))                   (distinct (q1         x!0)                             (q1_model42 x!0)))) [GOOD] (define-fun q2_model42 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 false) (= x!1 true)) true-          false)+          (ite (and (= x!0 false) (= x!1 true)) false+          (ite (and (= x!0 false) (= x!1 false)) false+          true))        ) [GOOD] (define-fun q2_model42_reject () Bool           (exists ((x!0 Bool) (x!1 Bool))@@ -1204,11 +1201,11 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q1))-[RECV] ((q1 ((as const Array) true)))+[RECV] ((q1 ((as const Array) false))) [SEND] (get-value (q2))-[RECV] ((q2 (store (store ((as const Array) false) false true true) true true true)))+[RECV] ((q2 (store ((as const Array) false) true true true))) [GOOD] (define-fun q1_model43 ((x!0 Bool)) Bool-          true+          false        ) [GOOD] (define-fun q1_model43_reject () Bool           (exists ((x!0 Bool))@@ -1216,8 +1213,7 @@                             (q1_model43 x!0)))) [GOOD] (define-fun q2_model43 ((x!0 Bool) (x!1 Bool)) Bool           (ite (and (= x!0 true) (= x!1 true)) true-          (ite (and (= x!0 false) (= x!1 true)) true-          false))+          false)        ) [GOOD] (define-fun q2_model43_reject () Bool           (exists ((x!0 Bool) (x!1 Bool))@@ -1232,20 +1228,19 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q1))-[RECV] ((q1 ((as const Array) true)))+[RECV] ((q1 ((as const Array) false))) [SEND] (get-value (q2))-[RECV] ((q2 (store (store ((as const Array) true) false false false) true true false)))+[RECV] ((q2 (store ((as const Array) true) false false false))) [GOOD] (define-fun q1_model44 ((x!0 Bool)) Bool-          true+          false        ) [GOOD] (define-fun q1_model44_reject () Bool           (exists ((x!0 Bool))                   (distinct (q1         x!0)                             (q1_model44 x!0)))) [GOOD] (define-fun q2_model44 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 true) (= x!1 true)) false           (ite (and (= x!0 false) (= x!1 false)) false-          true))+          true)        ) [GOOD] (define-fun q2_model44_reject () Bool           (exists ((x!0 Bool) (x!1 Bool))@@ -1260,19 +1255,20 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q1))-[RECV] ((q1 ((as const Array) true)))+[RECV] ((q1 (store ((as const Array) false) false true))) [SEND] (get-value (q2))-[RECV] ((q2 (store ((as const Array) true) false false false)))+[RECV] ((q2 (store ((as const Array) false) true false true))) [GOOD] (define-fun q1_model45 ((x!0 Bool)) Bool-          true+          (ite (and (= x!0 false)) true+          false)        ) [GOOD] (define-fun q1_model45_reject () Bool           (exists ((x!0 Bool))                   (distinct (q1         x!0)                             (q1_model45 x!0)))) [GOOD] (define-fun q2_model45 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 false) (= x!1 false)) false-          true)+          (ite (and (= x!0 true) (= x!1 false)) true+          false)        ) [GOOD] (define-fun q2_model45_reject () Bool           (exists ((x!0 Bool) (x!1 Bool))@@ -1287,20 +1283,21 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q1))-[RECV] ((q1 ((as const Array) true)))+[RECV] ((q1 (store ((as const Array) false) false true))) [SEND] (get-value (q2))-[RECV] ((q2 (store (store ((as const Array) true) false false false) false true false)))+[RECV] ((q2 (store (store ((as const Array) false) true false true) true true true))) [GOOD] (define-fun q1_model46 ((x!0 Bool)) Bool-          true+          (ite (and (= x!0 false)) true+          false)        ) [GOOD] (define-fun q1_model46_reject () Bool           (exists ((x!0 Bool))                   (distinct (q1         x!0)                             (q1_model46 x!0)))) [GOOD] (define-fun q2_model46 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 false) (= x!1 true)) false-          (ite (and (= x!0 false) (= x!1 false)) false-          true))+          (ite (and (= x!0 true) (= x!1 true)) true+          (ite (and (= x!0 true) (= x!1 false)) true+          false))        ) [GOOD] (define-fun q2_model46_reject () Bool           (exists ((x!0 Bool) (x!1 Bool))@@ -1315,18 +1312,19 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q1))-[RECV] ((q1 ((as const Array) true)))+[RECV] ((q1 (store ((as const Array) false) false true))) [SEND] (get-value (q2))-[RECV] ((q2 (store ((as const Array) false) true false true)))+[RECV] ((q2 (store ((as const Array) false) true true true))) [GOOD] (define-fun q1_model47 ((x!0 Bool)) Bool-          true+          (ite (and (= x!0 false)) true+          false)        ) [GOOD] (define-fun q1_model47_reject () Bool           (exists ((x!0 Bool))                   (distinct (q1         x!0)                             (q1_model47 x!0)))) [GOOD] (define-fun q2_model47 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 true) (= x!1 false)) true+          (ite (and (= x!0 true) (= x!1 true)) true           false)        ) [GOOD] (define-fun q2_model47_reject () Bool@@ -1342,19 +1340,19 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q1))-[RECV] ((q1 ((as const Array) true)))+[RECV] ((q1 (store ((as const Array) false) false true))) [SEND] (get-value (q2))-[RECV] ((q2 (store ((as const Array) false) true true true)))+[RECV] ((q2 ((as const Array) false))) [GOOD] (define-fun q1_model48 ((x!0 Bool)) Bool-          true+          (ite (and (= x!0 false)) true+          false)        ) [GOOD] (define-fun q1_model48_reject () Bool           (exists ((x!0 Bool))                   (distinct (q1         x!0)                             (q1_model48 x!0)))) [GOOD] (define-fun q2_model48 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 true) (= x!1 true)) true-          false)+          false        ) [GOOD] (define-fun q2_model48_reject () Bool           (exists ((x!0 Bool) (x!1 Bool))@@ -1369,20 +1367,19 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q1))-[RECV] ((q1 ((as const Array) false)))+[RECV] ((q1 ((as const Array) true))) [SEND] (get-value (q2))-[RECV] ((q2 (store (store ((as const Array) false) false true true) true false true)))+[RECV] ((q2 (store ((as const Array) false) true true true))) [GOOD] (define-fun q1_model49 ((x!0 Bool)) Bool-          false+          true        ) [GOOD] (define-fun q1_model49_reject () Bool           (exists ((x!0 Bool))                   (distinct (q1         x!0)                             (q1_model49 x!0)))) [GOOD] (define-fun q2_model49 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 true) (= x!1 false)) true-          (ite (and (= x!0 false) (= x!1 true)) true-          false))+          (ite (and (= x!0 true) (= x!1 true)) true+          false)        ) [GOOD] (define-fun q2_model49_reject () Bool           (exists ((x!0 Bool) (x!1 Bool))@@ -1397,19 +1394,18 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q1))-[RECV] ((q1 (store ((as const Array) false) false true)))+[RECV] ((q1 ((as const Array) true))) [SEND] (get-value (q2))-[RECV] ((q2 (store ((as const Array) false) true true true)))+[RECV] ((q2 (store ((as const Array) false) true false true))) [GOOD] (define-fun q1_model50 ((x!0 Bool)) Bool-          (ite (and (= x!0 false)) true-          false)+          true        ) [GOOD] (define-fun q1_model50_reject () Bool           (exists ((x!0 Bool))                   (distinct (q1         x!0)                             (q1_model50 x!0)))) [GOOD] (define-fun q2_model50 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 true) (= x!1 true)) true+          (ite (and (= x!0 true) (= x!1 false)) true           false)        ) [GOOD] (define-fun q2_model50_reject () Bool@@ -1425,11 +1421,11 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q1))-[RECV] ((q1 ((as const Array) false)))+[RECV] ((q1 ((as const Array) true))) [SEND] (get-value (q2))-[RECV] ((q2 (store ((as const Array) false) true true true)))+[RECV] ((q2 (store (store ((as const Array) false) true false true) true true true))) [GOOD] (define-fun q1_model51 ((x!0 Bool)) Bool-          false+          true        ) [GOOD] (define-fun q1_model51_reject () Bool           (exists ((x!0 Bool))@@ -1437,7 +1433,8 @@                             (q1_model51 x!0)))) [GOOD] (define-fun q2_model51 ((x!0 Bool) (x!1 Bool)) Bool           (ite (and (= x!0 true) (= x!1 true)) true-          false)+          (ite (and (= x!0 true) (= x!1 false)) true+          false))        ) [GOOD] (define-fun q2_model51_reject () Bool           (exists ((x!0 Bool) (x!1 Bool))@@ -1452,19 +1449,19 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q1))-[RECV] ((q1 (store ((as const Array) false) false true)))+[RECV] ((q1 ((as const Array) true))) [SEND] (get-value (q2))-[RECV] ((q2 ((as const Array) false)))+[RECV] ((q2 (store ((as const Array) false) false true true))) [GOOD] (define-fun q1_model52 ((x!0 Bool)) Bool-          (ite (and (= x!0 false)) true-          false)+          true        ) [GOOD] (define-fun q1_model52_reject () Bool           (exists ((x!0 Bool))                   (distinct (q1         x!0)                             (q1_model52 x!0)))) [GOOD] (define-fun q2_model52 ((x!0 Bool) (x!1 Bool)) Bool-          false+          (ite (and (= x!0 false) (= x!1 true)) true+          false)        ) [GOOD] (define-fun q2_model52_reject () Bool           (exists ((x!0 Bool) (x!1 Bool))@@ -1479,12 +1476,11 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q1))-[RECV] ((q1 (store ((as const Array) true) true false)))+[RECV] ((q1 ((as const Array) true))) [SEND] (get-value (q2))-[RECV] ((q2 (store ((as const Array) false) true false true)))+[RECV] ((q2 (store (store ((as const Array) false) false true true) true false true))) [GOOD] (define-fun q1_model53 ((x!0 Bool)) Bool-          (ite (and (= x!0 true)) false-          true)+          true        ) [GOOD] (define-fun q1_model53_reject () Bool           (exists ((x!0 Bool))@@ -1492,7 +1488,8 @@                             (q1_model53 x!0)))) [GOOD] (define-fun q2_model53 ((x!0 Bool) (x!1 Bool)) Bool           (ite (and (= x!0 true) (= x!1 false)) true-          false)+          (ite (and (= x!0 false) (= x!1 true)) true+          false))        ) [GOOD] (define-fun q2_model53_reject () Bool           (exists ((x!0 Bool) (x!1 Bool))@@ -1507,21 +1504,19 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q1))-[RECV] ((q1 (store ((as const Array) false) false true)))+[RECV] ((q1 ((as const Array) true))) [SEND] (get-value (q2))-[RECV] ((q2 (store (store ((as const Array) false) true false true) false true true)))+[RECV] ((q2 (store ((as const Array) true) false false false))) [GOOD] (define-fun q1_model54 ((x!0 Bool)) Bool-          (ite (and (= x!0 false)) true-          false)+          true        ) [GOOD] (define-fun q1_model54_reject () Bool           (exists ((x!0 Bool))                   (distinct (q1         x!0)                             (q1_model54 x!0)))) [GOOD] (define-fun q2_model54 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 false) (= x!1 true)) true-          (ite (and (= x!0 true) (= x!1 false)) true-          false))+          (ite (and (= x!0 false) (= x!1 false)) false+          true)        ) [GOOD] (define-fun q2_model54_reject () Bool           (exists ((x!0 Bool) (x!1 Bool))@@ -1536,21 +1531,20 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q1))-[RECV] ((q1 (store ((as const Array) true) true false)))+[RECV] ((q1 ((as const Array) true))) [SEND] (get-value (q2))-[RECV] ((q2 (store (store ((as const Array) false) true false true) true true true)))+[RECV] ((q2 (store (store ((as const Array) true) false false false) true false false))) [GOOD] (define-fun q1_model55 ((x!0 Bool)) Bool-          (ite (and (= x!0 true)) false-          true)+          true        ) [GOOD] (define-fun q1_model55_reject () Bool           (exists ((x!0 Bool))                   (distinct (q1         x!0)                             (q1_model55 x!0)))) [GOOD] (define-fun q2_model55 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 true) (= x!1 true)) true-          (ite (and (= x!0 true) (= x!1 false)) true-          false))+          (ite (and (= x!0 true) (= x!1 false)) false+          (ite (and (= x!0 false) (= x!1 false)) false+          true))        ) [GOOD] (define-fun q2_model55_reject () Bool           (exists ((x!0 Bool) (x!1 Bool))@@ -1567,7 +1561,7 @@ [SEND] (get-value (q1)) [RECV] ((q1 (store ((as const Array) true) true false))) [SEND] (get-value (q2))-[RECV] ((q2 (store ((as const Array) true) false true false)))+[RECV] ((q2 (store ((as const Array) false) false true true))) [GOOD] (define-fun q1_model56 ((x!0 Bool)) Bool           (ite (and (= x!0 true)) false           true)@@ -1577,8 +1571,8 @@                   (distinct (q1         x!0)                             (q1_model56 x!0)))) [GOOD] (define-fun q2_model56 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 false) (= x!1 true)) false-          true)+          (ite (and (= x!0 false) (= x!1 true)) true+          false)        ) [GOOD] (define-fun q2_model56_reject () Bool           (exists ((x!0 Bool) (x!1 Bool))@@ -1593,19 +1587,21 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q1))-[RECV] ((q1 ((as const Array) true)))+[RECV] ((q1 (store ((as const Array) true) true false))) [SEND] (get-value (q2))-[RECV] ((q2 (store ((as const Array) true) true false false)))+[RECV] ((q2 (store (store ((as const Array) false) false true true) true true true))) [GOOD] (define-fun q1_model57 ((x!0 Bool)) Bool-          true+          (ite (and (= x!0 true)) false+          true)        ) [GOOD] (define-fun q1_model57_reject () Bool           (exists ((x!0 Bool))                   (distinct (q1         x!0)                             (q1_model57 x!0)))) [GOOD] (define-fun q2_model57 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 true) (= x!1 false)) false-          true)+          (ite (and (= x!0 true) (= x!1 true)) true+          (ite (and (= x!0 false) (= x!1 true)) true+          false))        ) [GOOD] (define-fun q2_model57_reject () Bool           (exists ((x!0 Bool) (x!1 Bool))@@ -1622,7 +1618,7 @@ [SEND] (get-value (q1)) [RECV] ((q1 (store ((as const Array) true) true false))) [SEND] (get-value (q2))-[RECV] ((q2 (store ((as const Array) true) true false false)))+[RECV] ((q2 (store ((as const Array) true) false false false))) [GOOD] (define-fun q1_model58 ((x!0 Bool)) Bool           (ite (and (= x!0 true)) false           true)@@ -1632,7 +1628,7 @@                   (distinct (q1         x!0)                             (q1_model58 x!0)))) [GOOD] (define-fun q2_model58 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 true) (= x!1 false)) false+          (ite (and (= x!0 false) (= x!1 false)) false           true)        ) [GOOD] (define-fun q2_model58_reject () Bool@@ -1648,19 +1644,20 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q1))-[RECV] ((q1 (store ((as const Array) true) true false)))+[RECV] ((q1 ((as const Array) false))) [SEND] (get-value (q2))-[RECV] ((q2 ((as const Array) true)))+[RECV] ((q2 (store (store ((as const Array) true) true false false) false true false))) [GOOD] (define-fun q1_model59 ((x!0 Bool)) Bool-          (ite (and (= x!0 true)) false-          true)+          false        ) [GOOD] (define-fun q1_model59_reject () Bool           (exists ((x!0 Bool))                   (distinct (q1         x!0)                             (q1_model59 x!0)))) [GOOD] (define-fun q2_model59 ((x!0 Bool) (x!1 Bool)) Bool-          true+          (ite (and (= x!0 false) (= x!1 true)) false+          (ite (and (= x!0 true) (= x!1 false)) false+          true))        ) [GOOD] (define-fun q2_model59_reject () Bool           (exists ((x!0 Bool) (x!1 Bool))@@ -1675,18 +1672,20 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q1))-[RECV] ((q1 ((as const Array) true)))+[RECV] ((q1 ((as const Array) false))) [SEND] (get-value (q2))-[RECV] ((q2 ((as const Array) true)))+[RECV] ((q2 (store (store ((as const Array) true) true true false) false true false))) [GOOD] (define-fun q1_model60 ((x!0 Bool)) Bool-          true+          false        ) [GOOD] (define-fun q1_model60_reject () Bool           (exists ((x!0 Bool))                   (distinct (q1         x!0)                             (q1_model60 x!0)))) [GOOD] (define-fun q2_model60 ((x!0 Bool) (x!1 Bool)) Bool-          true+          (ite (and (= x!0 false) (= x!1 true)) false+          (ite (and (= x!0 true) (= x!1 true)) false+          true))        ) [GOOD] (define-fun q2_model60_reject () Bool           (exists ((x!0 Bool) (x!1 Bool))@@ -1701,20 +1700,20 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q1))-[RECV] ((q1 (store ((as const Array) true) true false)))+[RECV] ((q1 ((as const Array) false))) [SEND] (get-value (q2))-[RECV] ((q2 (store ((as const Array) true) false false false)))+[RECV] ((q2 (store (store ((as const Array) true) true false false) true true false))) [GOOD] (define-fun q1_model61 ((x!0 Bool)) Bool-          (ite (and (= x!0 true)) false-          true)+          false        ) [GOOD] (define-fun q1_model61_reject () Bool           (exists ((x!0 Bool))                   (distinct (q1         x!0)                             (q1_model61 x!0)))) [GOOD] (define-fun q2_model61 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 false) (= x!1 false)) false-          true)+          (ite (and (= x!0 true) (= x!1 true)) false+          (ite (and (= x!0 true) (= x!1 false)) false+          true))        ) [GOOD] (define-fun q2_model61_reject () Bool           (exists ((x!0 Bool) (x!1 Bool))@@ -1729,18 +1728,18 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q1))-[RECV] ((q1 ((as const Array) true)))+[RECV] ((q1 ((as const Array) false))) [SEND] (get-value (q2))-[RECV] ((q2 (store ((as const Array) true) true true false)))+[RECV] ((q2 (store ((as const Array) true) true false false))) [GOOD] (define-fun q1_model62 ((x!0 Bool)) Bool-          true+          false        ) [GOOD] (define-fun q1_model62_reject () Bool           (exists ((x!0 Bool))                   (distinct (q1         x!0)                             (q1_model62 x!0)))) [GOOD] (define-fun q2_model62 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 true) (= x!1 true)) false+          (ite (and (= x!0 true) (= x!1 false)) false           true)        ) [GOOD] (define-fun q2_model62_reject () Bool@@ -1756,19 +1755,21 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q1))-[RECV] ((q1 ((as const Array) false)))+[RECV] ((q1 (store ((as const Array) false) false true))) [SEND] (get-value (q2))-[RECV] ((q2 (store ((as const Array) true) true true false)))+[RECV] ((q2 (store (store ((as const Array) false) false true true) true false true))) [GOOD] (define-fun q1_model63 ((x!0 Bool)) Bool-          false+          (ite (and (= x!0 false)) true+          false)        ) [GOOD] (define-fun q1_model63_reject () Bool           (exists ((x!0 Bool))                   (distinct (q1         x!0)                             (q1_model63 x!0)))) [GOOD] (define-fun q2_model63 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 true) (= x!1 true)) false-          true)+          (ite (and (= x!0 true) (= x!1 false)) true+          (ite (and (= x!0 false) (= x!1 true)) true+          false))        ) [GOOD] (define-fun q2_model63_reject () Bool           (exists ((x!0 Bool) (x!1 Bool))@@ -1783,12 +1784,11 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q1))-[RECV] ((q1 (store ((as const Array) false) false true)))+[RECV] ((q1 ((as const Array) false))) [SEND] (get-value (q2)) [RECV] ((q2 (store ((as const Array) true) true true false))) [GOOD] (define-fun q1_model64 ((x!0 Bool)) Bool-          (ite (and (= x!0 false)) true-          false)+          false        ) [GOOD] (define-fun q1_model64_reject () Bool           (exists ((x!0 Bool))@@ -1815,256 +1815,262 @@  RESULT: Solution #1:   q1 :: Bool -> Bool-  q1 False = True -  q1 _     = False+  q1 _ = False    q2 :: Bool -> Bool -> Bool   q2 True True = False   q2 _    _    = True  Solution #2:   q1 :: Bool -> Bool-  q1 _ = False+  q1 False = True +  q1 _     = False    q2 :: Bool -> Bool -> Bool-  q2 True True = False-  q2 _    _    = True +  q2 True  False = True +  q2 False True  = True +  q2 _     _     = False Solution #3:   q1 :: Bool -> Bool-  q1 _ = True+  q1 _ = False    q2 :: Bool -> Bool -> Bool-  q2 True True = False-  q2 _    _    = True +  q2 True False = False+  q2 _    _     = True  Solution #4:   q1 :: Bool -> Bool-  q1 True = False-  q1 _    = True +  q1 _ = False    q2 :: Bool -> Bool -> Bool-  q2 False False = False-  q2 _     _     = True +  q2 True True  = False+  q2 True False = False+  q2 _    _     = True  Solution #5:   q1 :: Bool -> Bool-  q1 _ = True+  q1 _ = False    q2 :: Bool -> Bool -> Bool-  q2 _ _ = True+  q2 False True = False+  q2 True  True = False+  q2 _     _    = True  Solution #6:   q1 :: Bool -> Bool-  q1 True = False-  q1 _    = True +  q1 _ = False    q2 :: Bool -> Bool -> Bool-  q2 _ _ = True+  q2 False True  = False+  q2 True  False = False+  q2 _     _     = True  Solution #7:   q1 :: Bool -> Bool   q1 True = False   q1 _    = True     q2 :: Bool -> Bool -> Bool-  q2 True False = False-  q2 _    _     = True +  q2 False False = False+  q2 _     _     = True  Solution #8:   q1 :: Bool -> Bool-  q1 _ = True+  q1 True = False+  q1 _    = True     q2 :: Bool -> Bool -> Bool-  q2 True False = False-  q2 _    _     = True +  q2 True  True = True +  q2 False True = True +  q2 _     _    = False Solution #9:   q1 :: Bool -> Bool   q1 True = False   q1 _    = True     q2 :: Bool -> Bool -> Bool-  q2 False True = False-  q2 _     _    = True +  q2 False True = True +  q2 _     _    = False Solution #10:   q1 :: Bool -> Bool-  q1 True = False-  q1 _    = True +  q1 _ = True    q2 :: Bool -> Bool -> Bool-  q2 True True  = True -  q2 True False = True -  q2 _    _     = False+  q2 True  False = False+  q2 False False = False+  q2 _     _     = True  Solution #11:   q1 :: Bool -> Bool-  q1 False = True -  q1 _     = False+  q1 _ = True    q2 :: Bool -> Bool -> Bool-  q2 False True  = True -  q2 True  False = True -  q2 _     _     = False+  q2 False False = False+  q2 _     _     = True  Solution #12:   q1 :: Bool -> Bool-  q1 True = False-  q1 _    = True +  q1 _ = True    q2 :: Bool -> Bool -> Bool-  q2 True False = True -  q2 _    _     = False+  q2 True  False = True +  q2 False True  = True +  q2 _     _     = False Solution #13:   q1 :: Bool -> Bool-  q1 False = True -  q1 _     = False+  q1 _ = True    q2 :: Bool -> Bool -> Bool-  q2 _ _ = False+  q2 False True = True +  q2 _     _    = False Solution #14:   q1 :: Bool -> Bool-  q1 _ = False+  q1 _ = True    q2 :: Bool -> Bool -> Bool-  q2 True True = True -  q2 _    _    = False+  q2 True True  = True +  q2 True False = True +  q2 _    _     = False Solution #15:   q1 :: Bool -> Bool-  q1 False = True -  q1 _     = False+  q1 _ = True    q2 :: Bool -> Bool -> Bool-  q2 True True = True -  q2 _    _    = False+  q2 True False = True +  q2 _    _     = False Solution #16:   q1 :: Bool -> Bool-  q1 _ = False+  q1 _ = True    q2 :: Bool -> Bool -> Bool-  q2 True  False = True -  q2 False True  = True -  q2 _     _     = False+  q2 True True = True +  q2 _    _    = False Solution #17:   q1 :: Bool -> Bool-  q1 _ = True+  q1 False = True +  q1 _     = False    q2 :: Bool -> Bool -> Bool-  q2 True True = True -  q2 _    _    = False+  q2 _ _ = False Solution #18:   q1 :: Bool -> Bool-  q1 _ = True+  q1 False = True +  q1 _     = False    q2 :: Bool -> Bool -> Bool-  q2 True False = True -  q2 _    _     = False+  q2 True True = True +  q2 _    _    = False Solution #19:   q1 :: Bool -> Bool-  q1 _ = True+  q1 False = True +  q1 _     = False    q2 :: Bool -> Bool -> Bool-  q2 False True  = False-  q2 False False = False-  q2 _     _     = True +  q2 True True  = True +  q2 True False = True +  q2 _    _     = False Solution #20:   q1 :: Bool -> Bool-  q1 _ = True+  q1 False = True +  q1 _     = False    q2 :: Bool -> Bool -> Bool-  q2 False False = False-  q2 _     _     = True +  q2 True False = True +  q2 _    _     = False Solution #21:   q1 :: Bool -> Bool-  q1 _ = True+  q1 _ = False    q2 :: Bool -> Bool -> Bool-  q2 True  True  = False   q2 False False = False   q2 _     _     = True  Solution #22:   q1 :: Bool -> Bool-  q1 _ = True+  q1 _ = False    q2 :: Bool -> Bool -> Bool-  q2 True  True = True -  q2 False True = True -  q2 _     _    = False+  q2 True True = True +  q2 _    _    = False Solution #23:   q1 :: Bool -> Bool-  q1 _ = True+  q1 _ = False    q2 :: Bool -> Bool -> Bool-  q2 False True = True -  q2 _     _    = False+  q2 False True  = False+  q2 False False = False+  q2 _     _     = True  Solution #24:   q1 :: Bool -> Bool-  q1 False = True -  q1 _     = False+  q1 _ = False    q2 :: Bool -> Bool -> Bool-  q2 True  True = True    q2 False True = True    q2 _     _    = False Solution #25:   q1 :: Bool -> Bool-  q1 False = True -  q1 _     = False+  q1 _ = False    q2 :: Bool -> Bool -> Bool-  q2 False True = True -  q2 _     _    = False+  q2 False False = False+  q2 True  False = False+  q2 _     _     = True  Solution #26:   q1 :: Bool -> Bool-  q1 _ = False+  q1 False = True +  q1 _     = False    q2 :: Bool -> Bool -> Bool-  q2 False True = True -  q2 _     _    = False+  q2 True False = False+  q2 _    _     = True  Solution #27:   q1 :: Bool -> Bool-  q1 _ = False+  q1 False = True +  q1 _     = False    q2 :: Bool -> Bool -> Bool-  q2 False True = True -  q2 True  True = True -  q2 _     _    = False+  q2 False False = True +  q2 False True  = True +  q2 _     _     = False Solution #28:   q1 :: Bool -> Bool   q1 True = True    q1 _    = False    q2 :: Bool -> Bool -> Bool-  q2 False True = True -  q2 True  True = True -  q2 _     _    = False+  q2 True True = True +  q2 _    _    = False Solution #29:   q1 :: Bool -> Bool   q1 True = True    q1 _    = False    q2 :: Bool -> Bool -> Bool-  q2 True True  = True -  q2 True False = True -  q2 _    _     = False+  q2 False True = True +  q2 True  True = True +  q2 _     _    = False Solution #30:   q1 :: Bool -> Bool-  q1 _ = False+  q1 True = True +  q1 _    = False    q2 :: Bool -> Bool -> Bool-  q2 True True  = True -  q2 True False = True -  q2 _    _     = False+  q2 False True  = True +  q2 True  False = True +  q2 _     _     = False Solution #31:   q1 :: Bool -> Bool   q1 _ = False    q2 :: Bool -> Bool -> Bool-  q2 True False = True -  q2 _    _     = False+  q2 False True  = True +  q2 True  False = True +  q2 _     _     = False Solution #32:   q1 :: Bool -> Bool   q1 _ = False    q2 :: Bool -> Bool -> Bool-  q2 False False = False-  q2 _     _     = True +  q2 True False = True +  q2 _    _     = False Solution #33:   q1 :: Bool -> Bool   q1 True = True    q1 _    = False    q2 :: Bool -> Bool -> Bool+  q2 True True  = True    q2 True False = True    q2 _    _     = False Solution #34:@@ -2073,17 +2079,16 @@   q1 _    = False    q2 :: Bool -> Bool -> Bool-  q2 True True = True -  q2 _    _    = False+  q2 True False = True +  q2 _    _     = False Solution #35:   q1 :: Bool -> Bool   q1 True = True    q1 _    = False    q2 :: Bool -> Bool -> Bool-  q2 True  False = True -  q2 False True  = True -  q2 _     _     = False+  q2 False False = False+  q2 _     _     = True  Solution #36:   q1 :: Bool -> Bool   q1 True = True @@ -2098,79 +2103,74 @@   q1 _    = False    q2 :: Bool -> Bool -> Bool-  q2 False False = False-  q2 _     _     = True +  q2 _ _ = False Solution #38:   q1 :: Bool -> Bool   q1 True = True    q1 _    = False    q2 :: Bool -> Bool -> Bool-  q2 _ _ = False+  q2 False True  = True +  q2 False False = True +  q2 _     _     = False Solution #39:   q1 :: Bool -> Bool-  q1 False = True -  q1 _     = False+  q1 _ = True    q2 :: Bool -> Bool -> Bool-  q2 True True  = False-  q2 True False = False-  q2 _    _     = True +  q2 False True  = True +  q2 False False = True +  q2 _     _     = False Solution #40:   q1 :: Bool -> Bool-  q1 _ = False+  q1 _ = True    q2 :: Bool -> Bool -> Bool   q2 True False = False   q2 _    _     = True  Solution #41:   q1 :: Bool -> Bool-  q1 _ = False+  q1 True = False+  q1 _    = True     q2 :: Bool -> Bool -> Bool-  q2 True True  = False-  q2 True False = False-  q2 _    _     = True +  q2 True True = False+  q2 _    _    = True  Solution #42:   q1 :: Bool -> Bool-  q1 True = True -  q1 _    = False+  q1 True = False+  q1 _    = True     q2 :: Bool -> Bool -> Bool-  q2 True False = False-  q2 True True  = False-  q2 _    _     = True +  q2 _ _ = True Solution #43:   q1 :: Bool -> Bool   q1 _ = True    q2 :: Bool -> Bool -> Bool-  q2 True False = False-  q2 True True  = False-  q2 _    _     = True +  q2 _ _ = True Solution #44:   q1 :: Bool -> Bool   q1 _ = True    q2 :: Bool -> Bool -> Bool-  q2 False True = False-  q2 _     _    = True +  q2 True True = False+  q2 _    _    = True  Solution #45:   q1 :: Bool -> Bool-  q1 _ = False+  q1 _ = True    q2 :: Bool -> Bool -> Bool   q2 False True = False-  q2 True  True = False   q2 _     _    = True  Solution #46:   q1 :: Bool -> Bool-  q1 _ = False+  q1 True = False+  q1 _    = True     q2 :: Bool -> Bool -> Bool-  q2 True  False = False-  q2 False True  = False-  q2 _     _     = True +  q2 False True = False+  q2 _     _    = True  Solution #47:   q1 :: Bool -> Bool   q1 True = False
SBVTestSuite/GoldFiles/validate_0.gold view
@@ -30,25 +30,16 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (s0))-[RECV] ((s0 #xff))+[RECV] ((s0 #x0)) *** Solver   : ABC *** Exit code: ExitSuccess+*** Std-err  : Cmd warning: redefining '%graft' [VALIDATE] Validating the model. Assignment:-[VALIDATE]       x = 255 :: Word8+[VALIDATE]       x = 0 :: Word8 [VALIDATE] There are no constraints to check. [VALIDATE] Validating outputs.+[VALIDATE] All outputs are satisfied. Validation complete.  FINAL OUTPUT:-*** Data.SBV: Model validation failure: Final output evaluated to False.-*** -*** Assignment:-*** -***       x = 255 :: Word8-*** -*** Backend solver returned a model that does not satisfy the constraints.-*** This could indicate a bug in the backend solver, or SBV itself. Please report.-***-*** Alleged model:-***-*** Satisfiable. Model:-***   x = 255 :: Word8+Satisfiable. Model:+  x = 0 :: Word8
SBVTestSuite/SBVDocTest.hs view
@@ -9,91 +9,12 @@ -- Doctest interface for SBV testsuite ----------------------------------------------------------------------------- -{-# OPTIONS_GHC -Wall -Werror #-}+{-# OPTIONS_GHC -Wall #-}  module Main (main) where -import System.FilePath.Glob (glob)-import Test.DocTest (doctest)--import Data.Char (toLower)-import Data.List (isSuffixOf)--import System.Exit (exitSuccess)--import Utils.SBVTestFramework (getTestEnvironment, TestEnvironment(..), CIOS(..))--import System.Random (randomRIO)---- For temporarily testing only a few files-testOnly :: FilePath -> Bool-testOnly f = case only of-               Nothing -> True-               Just xs -> any (`isSuffixOf` f) xs-  where only :: Maybe [FilePath]-        only = Nothing+import System.Process+import System.Exit(exitWith)  main :: IO ()-main = do (testEnv, testPercentage) <- getTestEnvironment--          putStrLn $ "SBVDocTest: Test platform: " ++ show testEnv--          case testEnv of-            TestEnvLocal   -> runDocTest False False 100-            TestEnvCI env  -> if testPercentage < 50-                              then do putStrLn $ "Test percentage below threshold, skipping doctest: " ++ show testPercentage-                                      exitSuccess-                              else runDocTest (env == CIWindows) True testPercentage-            TestEnvUnknown  -> do putStrLn "Unknown test environment, skipping doctests"-                                  exitSuccess-- where runDocTest onWindows onRemote tp = do srcFiles <- glob "Data/SBV/**/*.hs"-                                             docFiles <- glob "Documentation/SBV/**/*.hs"--                                             let allFiles  = [f | f <- srcFiles ++ docFiles, testOnly f]-                                                 testFiles = filter (\nm -> not (skipWindows nm || skipRemote nm || skipLocal nm)) allFiles--                                                 packages = [ "async"-                                                            , "mtl"-                                                            , "QuickCheck"-                                                            , "random"-                                                            , "syb"-                                                            , "uniplate"-                                                            , "libBF"-                                                            ]--                                                 pargs = concatMap (\p -> ["-package", p]) packages-                                                 args  = ["--fast", "--no-magic"]--                                             tfs <- pickPercentage tp testFiles--                                             doctest $ pargs ++ args ++ tfs--         where noGood nm = any $ (`isSuffixOf` map toLower nm) . map toLower--               skipWindows nm-                 | not onWindows = False-                 | True          = noGood nm skipList-                 where skipList = [ "NoDiv0.hs"         -- Has a safety check and windows paths are printed differently-                                  , "BrokenSearch.hs"   -- Ditto-                                  ]-               skipRemote nm-                 | not onRemote = False-                 | True         = noGood nm skipList-                 where skipList = [ "Interpolants.hs"  -- This test requires mathSAT, so can't run on remote-                                  , "HexPuzzle.hs"     -- Doctest is way too slow on this with ghci loading, sigh-                                  ]--               -- These are the doctests we currently skip *everywhere* because there's some issue-               -- with an external tool or some other issue that stops us from fixing it. NB. Each-               -- of these should be accompanied by a ticket!-               skipLocal nm = noGood nm skipList-                 where skipList = []---- Pick (about) the given percentage of files-pickPercentage :: Int -> [String] -> IO [String]-pickPercentage 100 xs = return xs-pickPercentage   0 _  = return []-pickPercentage   p xs = concat <$> mapM pick xs-  where pick f = do c <- randomRIO (0, 100)-                    return [f | c >= p]+main = exitWith =<< rawSystem "cabal-docspec" ["--timeout", "120"]
SBVTestSuite/SBVHLint.hs view
@@ -13,8 +13,6 @@  module Main (main) where -import Utils.SBVTestFramework (getTestEnvironment, TestEnvironment(..))- import Language.Haskell.HLint (hlint) import System.Exit (exitFailure, exitSuccess) @@ -28,20 +26,7 @@     ]  main :: IO ()-main = do-    (testEnv, testPercentage) <- getTestEnvironment--    putStrLn $ "SBVHLint: Test platform: " ++ show testEnv--    case testEnv of-      TestEnvLocal   -> runHLint-      TestEnvCI{}    -> if testPercentage < 50-                           then do putStrLn $ "Test percentage below threshold, skipping hlint: " ++ show testPercentage-                                   exitSuccess-                           else runHLint-      TestEnvUnknown -> do putStrLn "Unknown test environment, skipping hlint run"-                           exitSuccess- where runHLint = do hints <- hlint arguments-                     if null hints-                        then exitSuccess-                        else exitFailure+main = do hints <- hlint arguments+          if null hints+             then exitSuccess+             else exitFailure
SBVTestSuite/SBVTest.hs view
@@ -17,10 +17,6 @@  import Test.Tasty -import Utils.SBVTestFramework (getTestEnvironment, TestEnvironment(..), CIOS(..), pickTests)--import System.Exit (exitSuccess)- import qualified TestSuite.Arrays.InitVals import qualified TestSuite.Arrays.Memory import qualified TestSuite.Arrays.Query@@ -127,147 +123,113 @@ import qualified TestSuite.Uninterpreted.Sort import qualified TestSuite.Uninterpreted.Uninterpreted --- On remote machines for Appveyor/Travis, the build machines doesn't have enough memory--- and/or powerful enough to run our heavy tests; so we skip tests for Windows hosts and--- reduce them for OSX. For Linux, we run them all. Note that this is only for remote--- hosts; when we run locally, all tests are run.------ TODO: Would be nice to run them all on Windows/OSX on remote hosts as well.-ciFilter :: CIOS -> Int -> TestTree -> IO TestTree-ciFilter _  100 tt = return tt-ciFilter os   n tt = do putStrLn $ "OS: " ++ show os ++ ", Running only " ++ show n ++ "% of arithmetic tests."-                        pickTests n tt- main :: IO ()-main = do (testEnv, testPercentage) <- getTestEnvironment--          putStrLn $ "SBVTest: Test platform: " ++ show testEnv--          case testEnv of-            TestEnvUnknown   -> do putStrLn "Unknown test environment, skipping tests"-                                   exitSuccess--            TestEnvLocal     -> defaultMain $ testGroup "Local" [heavyTests, localOnlyTests, otherTests]--            TestEnvCI os     -> do reducedHeavyTests <- ciFilter os testPercentage heavyTests-                                   defaultMain $ testGroup "Remote" [reducedHeavyTests, otherTests]---- | The following tests take too long/too burdensome for remote tests, so we run only a percentage of them-heavyTests :: TestTree-heavyTests = testGroup "SBVHeavyTests" [TestSuite.Basics.ArithSolver.tests]---- | The following tests can only be run locally-localOnlyTests :: TestTree-localOnlyTests = testGroup "SBVLocalOnlyTests" [-                     TestSuite.Basics.Exceptions.testsLocal-                   , TestSuite.Basics.BarrelRotate.tests      -- Requires CVC4-                   , TestSuite.Basics.ModelValidate.testsABC  -- Requires ABC-                   , TestSuite.Queries.BasicQuery.tests-                   , TestSuite.Queries.DSat.tests             -- Requires dReal-                   , TestSuite.Queries.BadOption.tests-                   , TestSuite.Queries.Int_ABC.tests-                   , TestSuite.Queries.Int_Boolector.tests-                   , TestSuite.Queries.Int_CVC4.tests-                   , TestSuite.Queries.Int_Mathsat.tests-                   , TestSuite.Queries.Int_Yices.tests-                   , TestSuite.Queries.Interpolants.tests     -- requires MathSat-                   , TestSuite.QuickCheck.QC.tests            -- runs too slow, so only local-                   ]---- | Remaining tests-otherTests :: TestTree-otherTests = testGroup "SBVTests" [-                 TestSuite.Arrays.InitVals.tests-               , TestSuite.Arrays.Memory.tests-               , TestSuite.Arrays.Query.tests-               , TestSuite.Arrays.Caching.tests-               , TestSuite.Basics.AllSat.tests-               , TestSuite.Basics.ArbFloats.tests-               , TestSuite.Basics.ArithNoSolver.tests-               , TestSuite.Basics.Assert.tests-               , TestSuite.Basics.BasicTests.tests-               , TestSuite.Basics.BoundedList.tests-               , TestSuite.Basics.DynSign.tests-               , TestSuite.Basics.Exceptions.testsRemote-               , TestSuite.Basics.GenBenchmark.tests-               , TestSuite.Basics.Higher.tests-               , TestSuite.Basics.Index.tests-               , TestSuite.Basics.IteTest.tests-               , TestSuite.Basics.List.tests-               , TestSuite.Basics.ModelValidate.tests-               , TestSuite.Basics.ProofTests.tests-               , TestSuite.Basics.PseudoBoolean.tests-               , TestSuite.Basics.QRem.tests-               , TestSuite.Basics.Quantifiers.tests-               , TestSuite.Basics.Recursive.tests-               , TestSuite.Basics.Set.tests-               , TestSuite.Basics.SmallShifts.tests-               , TestSuite.Basics.SquashReals.tests-               , TestSuite.Basics.String.tests-               , TestSuite.Basics.Sum.tests-               , TestSuite.Basics.TOut.tests-               , TestSuite.Basics.Tuple.tests-               , TestSuite.Basics.UISat.tests-               , TestSuite.BitPrecise.BitTricks.tests-               , TestSuite.BitPrecise.Legato.tests-               , TestSuite.BitPrecise.MergeSort.tests-               , TestSuite.BitPrecise.PrefixSum.tests-               , TestSuite.Char.Char.tests-               , TestSuite.CodeGeneration.AddSub.tests-               , TestSuite.CodeGeneration.CgTests.tests-               , TestSuite.CodeGeneration.CRC_USB5.tests-               , TestSuite.CodeGeneration.Fibonacci.tests-               , TestSuite.CodeGeneration.Floats.tests-               , TestSuite.CodeGeneration.GCD.tests-               , TestSuite.CodeGeneration.PopulationCount.tests-               , TestSuite.CodeGeneration.Uninterpreted.tests-               , TestSuite.CRC.CCITT.tests-               , TestSuite.CRC.CCITT_Unidir.tests-               , TestSuite.CRC.GenPoly.tests-               , TestSuite.CRC.Parity.tests-               , TestSuite.CRC.USB5.tests-               , TestSuite.Crypto.AES.tests-               , TestSuite.Crypto.RC4.tests-               , TestSuite.Crypto.SHA.tests-               , TestSuite.Existentials.CRCPolynomial.tests-               , TestSuite.GenTest.GenTests.tests-               , TestSuite.Optimization.AssertWithPenalty.tests-               , TestSuite.Optimization.Basics.tests-               , TestSuite.Optimization.Combined.tests-               , TestSuite.Optimization.ExtensionField.tests-               , TestSuite.Optimization.Floats.tests-               , TestSuite.Optimization.NoOpt.tests-               , TestSuite.Optimization.Tuples.tests-               , TestSuite.Optimization.Quantified.tests-               , TestSuite.Optimization.Reals.tests-               , TestSuite.Overflows.Arithmetic.tests-               , TestSuite.Overflows.Casts.tests-               , TestSuite.Polynomials.Polynomials.tests-               , TestSuite.Puzzles.Coins.tests-               , TestSuite.Puzzles.Counts.tests-               , TestSuite.Puzzles.DogCatMouse.tests-               , TestSuite.Puzzles.Euler185.tests-               , TestSuite.Puzzles.MagicSquare.tests-               , TestSuite.Puzzles.NQueens.tests-               , TestSuite.Puzzles.PowerSet.tests-               , TestSuite.Puzzles.Sudoku.tests-               , TestSuite.Puzzles.Temperature.tests-               , TestSuite.Puzzles.U2Bridge.tests-               , TestSuite.Queries.Enums.tests-               , TestSuite.Queries.FreshVars.tests-               , TestSuite.Queries.Int_Z3.tests-               , TestSuite.Queries.Lists.tests-               , TestSuite.Queries.Strings.tests-               , TestSuite.Queries.Sums.tests-               , TestSuite.Queries.Tables.tests-               , TestSuite.Queries.Tuples.tests-               , TestSuite.Queries.UISat.tests-               , TestSuite.Queries.UISatEx.tests-               , TestSuite.Queries.Uninterpreted.tests-               , TestSuite.Transformers.SymbolicEval.tests-               , TestSuite.Uninterpreted.AUF.tests-               , TestSuite.Uninterpreted.Axioms.tests-               , TestSuite.Uninterpreted.Function.tests-               , TestSuite.Uninterpreted.Sort.tests-               , TestSuite.Uninterpreted.Uninterpreted.tests-               ]+main = defaultMain $ testGroup "SBV" [+                        TestSuite.Arrays.InitVals.tests+                      , TestSuite.Arrays.Memory.tests+                      , TestSuite.Arrays.Query.tests+                      , TestSuite.Arrays.Caching.tests+                      , TestSuite.Basics.AllSat.tests+                      , TestSuite.Basics.ArbFloats.tests+                      , TestSuite.Basics.ArithNoSolver.tests+                      , TestSuite.Basics.ArithSolver.tests+                      , TestSuite.Basics.Assert.tests+                      , TestSuite.Basics.BarrelRotate.tests+                      , TestSuite.Basics.BasicTests.tests+                      , TestSuite.Basics.BoundedList.tests+                      , TestSuite.Basics.DynSign.tests+                      , TestSuite.Basics.Exceptions.testsLocal+                      , TestSuite.Basics.Exceptions.testsRemote+                      , TestSuite.Basics.GenBenchmark.tests+                      , TestSuite.Basics.Higher.tests+                      , TestSuite.Basics.Index.tests+                      , TestSuite.Basics.IteTest.tests+                      , TestSuite.Basics.List.tests+                      , TestSuite.Basics.ModelValidate.tests+                      , TestSuite.Basics.ModelValidate.testsABC+                      , TestSuite.Basics.ProofTests.tests+                      , TestSuite.Basics.PseudoBoolean.tests+                      , TestSuite.Basics.QRem.tests+                      , TestSuite.Basics.Quantifiers.tests+                      , TestSuite.Basics.Recursive.tests+                      , TestSuite.Basics.Set.tests+                      , TestSuite.Basics.SmallShifts.tests+                      , TestSuite.Basics.SquashReals.tests+                      , TestSuite.Basics.String.tests+                      , TestSuite.Basics.Sum.tests+                      , TestSuite.Basics.TOut.tests+                      , TestSuite.Basics.Tuple.tests+                      , TestSuite.Basics.UISat.tests+                      , TestSuite.BitPrecise.BitTricks.tests+                      , TestSuite.BitPrecise.Legato.tests+                      , TestSuite.BitPrecise.MergeSort.tests+                      , TestSuite.BitPrecise.PrefixSum.tests+                      , TestSuite.Char.Char.tests+                      , TestSuite.CodeGeneration.AddSub.tests+                      , TestSuite.CodeGeneration.CgTests.tests+                      , TestSuite.CodeGeneration.CRC_USB5.tests+                      , TestSuite.CodeGeneration.Fibonacci.tests+                      , TestSuite.CodeGeneration.Floats.tests+                      , TestSuite.CodeGeneration.GCD.tests+                      , TestSuite.CodeGeneration.PopulationCount.tests+                      , TestSuite.CodeGeneration.Uninterpreted.tests+                      , TestSuite.CRC.CCITT.tests+                      , TestSuite.CRC.CCITT_Unidir.tests+                      , TestSuite.CRC.GenPoly.tests+                      , TestSuite.CRC.Parity.tests+                      , TestSuite.CRC.USB5.tests+                      , TestSuite.Crypto.AES.tests+                      , TestSuite.Crypto.RC4.tests+                      , TestSuite.Crypto.SHA.tests+                      , TestSuite.Existentials.CRCPolynomial.tests+                      , TestSuite.GenTest.GenTests.tests+                      , TestSuite.Optimization.AssertWithPenalty.tests+                      , TestSuite.Optimization.Basics.tests+                      , TestSuite.Optimization.Combined.tests+                      , TestSuite.Optimization.ExtensionField.tests+                      , TestSuite.Optimization.Floats.tests+                      , TestSuite.Optimization.NoOpt.tests+                      , TestSuite.Optimization.Tuples.tests+                      , TestSuite.Optimization.Quantified.tests+                      , TestSuite.Optimization.Reals.tests+                      , TestSuite.Overflows.Arithmetic.tests+                      , TestSuite.Overflows.Casts.tests+                      , TestSuite.Polynomials.Polynomials.tests+                      , TestSuite.Puzzles.Coins.tests+                      , TestSuite.Puzzles.Counts.tests+                      , TestSuite.Puzzles.DogCatMouse.tests+                      , TestSuite.Puzzles.Euler185.tests+                      , TestSuite.Puzzles.MagicSquare.tests+                      , TestSuite.Puzzles.NQueens.tests+                      , TestSuite.Puzzles.PowerSet.tests+                      , TestSuite.Puzzles.Sudoku.tests+                      , TestSuite.Puzzles.Temperature.tests+                      , TestSuite.Puzzles.U2Bridge.tests+                      , TestSuite.Queries.BadOption.tests+                      , TestSuite.Queries.BasicQuery.tests+                      , TestSuite.Queries.DSat.tests+                      , TestSuite.Queries.Interpolants.tests+                      , TestSuite.Queries.Enums.tests+                      , TestSuite.Queries.FreshVars.tests+                      , TestSuite.Queries.Int_Z3.tests+                      , TestSuite.Queries.Int_ABC.tests+                      , TestSuite.Queries.Int_Boolector.tests+                      , TestSuite.Queries.Int_CVC4.tests+                      , TestSuite.Queries.Int_Mathsat.tests+                      , TestSuite.Queries.Int_Yices.tests+                      , TestSuite.Queries.Lists.tests+                      , TestSuite.Queries.Strings.tests+                      , TestSuite.Queries.Sums.tests+                      , TestSuite.Queries.Tables.tests+                      , TestSuite.Queries.Tuples.tests+                      , TestSuite.Queries.UISat.tests+                      , TestSuite.Queries.UISatEx.tests+                      , TestSuite.Queries.Uninterpreted.tests+                      , TestSuite.QuickCheck.QC.tests+                      , TestSuite.Transformers.SymbolicEval.tests+                      , TestSuite.Uninterpreted.AUF.tests+                      , TestSuite.Uninterpreted.Axioms.tests+                      , TestSuite.Uninterpreted.Function.tests+                      , TestSuite.Uninterpreted.Sort.tests+                      , TestSuite.Uninterpreted.Uninterpreted.tests+                      ]
SBVTestSuite/TestSuite/Arrays/Memory.hs view
@@ -50,12 +50,12 @@  -- | Extensionality extensionality :: Memory -> Memory -> Predicate-extensionality m1 m2 = do i <- exists_+extensionality m1 m2 = do i <- sbvExists_                           return $ (readArray m1 i ./= readArray m2 i) .|| m1 .== m2  -- | Extensionality, second variant. Expressible for both kinds of arrays. extensionality2 :: Memory -> Memory -> Address -> Predicate-extensionality2 m1 m2 i = do j <- exists_+extensionality2 m1 m2 i = do j <- sbvExists_                              return $ (readArray m1 j ./= readArray m2 j) .|| readArray m1 i .== readArray m2 i  -- | Merge, using memory equality to check result
SBVTestSuite/TestSuite/Basics/AllSat.hs view
@@ -34,7 +34,7 @@     , goldenVsStringShow "allSat3" $            allSat $ \x -> x .== (0::SFloat)     , goldenVsStringShow "allSat4" $            allSat $ \x -> x .<  (0::SWord8)     , goldenVsStringShow "allSat5" $ fmap srt $ allSat $ \x y -> x .< y .&& y .< (4::SWord8)-    , goldenVsStringShow "allSat6" $            allSat $ exists "x" >>= \x -> exists "y" >>= \y -> forall "z" >>= \z -> return (x .< (y::SWord8) .&& y .< 3 .&& z .== (z::SWord8))+    , goldenVsStringShow "allSat6" $            allSat $ sbvExists "x" >>= \x -> sbvExists "y" >>= \y -> sbvForall "z" >>= \z -> return (x .< (y::SWord8) .&& y .< 3 .&& z .== (z::SWord8))     , goldenCapturedIO   "allSat7" $ \rf -> void (allSatWith z3{verbose=True, redirectVerbose=Just rf} t3)     ]
SBVTestSuite/TestSuite/Basics/ArithSolver.hs view
@@ -14,6 +14,7 @@ {-# LANGUAGE FlexibleContexts    #-} {-# LANGUAGE Rank2Types          #-} {-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE DataKinds           #-}  {-# OPTIONS_GHC -Wall -Werror #-} @@ -33,7 +34,9 @@ tests :: TestTree tests =   testGroup "Basics.ArithSolver"-   (    genReals+   (    genExtends+     ++ genConcats+     ++ genReals      ++ genFloats      ++ genDoubles      ++ genFPConverts@@ -76,6 +79,35 @@      ++ genLists      ) +genExtends :: [TestTree]+genExtends = map mkTest $  [("signExtend-word", show x, mkThm signExtend x (signExtend (literal x) :: SWord 16)) | x <- wn8s]+                        ++ [("signExtend-int",  show x, mkThm signExtend x (signExtend (literal x) :: SInt 16))  | x <- in8s]+                        ++ [("zeroExtend-word", show x, mkThm zeroExtend x (zeroExtend (literal x) :: SWord 16)) | x <- wn8s]+                        ++ [("zeroExtend-int",  show x, mkThm zeroExtend x (zeroExtend (literal x) :: SInt 16))  | x <- in8s]+  where+    mkTest (nm, x, t) = testCase ("genExtends-" ++ nm ++ "." ++ x) (assert t)+    mkThm op x sr+      | Just r <- unliteral sr+      = isTheorem $ do a <- free "x"+                       constrain $ a .== literal x+                       return $ literal r .== op a+      | True+      = return False++genConcats :: [TestTree]+genConcats = map mkTest $  [("word", show x, show y, mkThm2 (#) x y (literal x # literal y)) | x <- wn8s, y <- wn8s]+                        ++ [("int",  show x, show y, mkThm2 (#) x y (literal x # literal y)) | x <- in8s, y <- in8s]+  where+    mkTest (nm, x, y, t) = testCase ("genConcats-" ++ nm ++ "." ++ x ++ "_" ++ y) (assert t)+    mkThm2 op x y sr+      | Just r <- unliteral sr+      = isTheorem $ do [a, b] <- mapM free ["a", "b"]+                       constrain $ a .== literal x+                       constrain $ b .== literal y+                       return $ literal r .== a `op` b+      | True+      = return False+ genBinTest :: Bool -> String -> (forall a. (Num a, Bits a) => a -> a -> a) -> [TestTree] genBinTest unboundedOK nm op = map mkTest $  [(show x, show y, mkThm2 x y (x `op` y)) | x <- w8s,  y <- w8s ]                                           ++ [(show x, show y, mkThm2 x y (x `op` y)) | x <- w16s, y <- w16s]@@ -780,6 +812,12 @@  i64s :: [Int64] i64s = xsSigned++wn8s :: [WordN 8]+wn8s = xsUnsigned++in8s :: [IntN 8]+in8s = xsSigned  iUBs :: [Integer] iUBs = [-1000000] ++ [-1 .. 1] ++ [1000000]
SBVTestSuite/TestSuite/Basics/BarrelRotate.hs view
@@ -88,8 +88,8 @@         , goldenCapturedIO "barrelRotate_Right_Word64_Word32" $ check $ checkRight  @Word64 @Word32         , goldenCapturedIO "barrelRotate_Right_Word64_Word64" $ check $ checkRight  @Word64 @Word64         ]-    where -- NB. We use CVC4 for these tests as Z3 is rather slow!-          check f gf = do r <- proveWith cvc4{verbose = True, redirectVerbose = Just gf} f+    where -- NB. We use CVC5 for these tests as Z3 is rather slow!+          check f gf = do r <- proveWith cvc5{verbose = True, redirectVerbose = Just gf} f                           appendFile gf ("\nFINAL:\n" ++ show r ++ "\nDONE!\n")            checkLeft :: forall a b. (SFiniteBits a, SFiniteBits b, SIntegral a, SIntegral b) => SBV a -> SBV b -> SBool
SBVTestSuite/TestSuite/Basics/BasicTests.hs view
@@ -16,7 +16,7 @@  module TestSuite.Basics.BasicTests(tests) where -import Data.SBV.Internals hiding (forall, output)+import Data.SBV.Internals hiding (sbvForall, output) import Utils.SBVTestFramework  -- Test suite@@ -62,16 +62,16 @@                           y = literal (2 :: Word8)                       output $ f x y test2 f = runSAT $ do let x = literal (3 :: Word8)-                      y :: SWord8 <- forall "y"+                      y :: SWord8 <- sbvForall "y"                       output $ f x y-test3 f = runSAT $ do x :: SWord8 <- forall "x"-                      y :: SWord8 <- forall "y"+test3 f = runSAT $ do x :: SWord8 <- sbvForall "x"+                      y :: SWord8 <- sbvForall "y"                       output $ f x y-test4 f = runSAT $ do x :: SWord8 <- forall "x"+test4 f = runSAT $ do x :: SWord8 <- sbvForall "x"                       output $ f x x-test5 f = runSAT $ do x :: SWord8 <- forall "x"+test5 f = runSAT $ do x :: SWord8 <- sbvForall "x"                       let r = f x x-                      q :: SWord8 <- forall "q"+                      q :: SWord8 <- sbvForall "q"                       _ <- output q                       output r
SBVTestSuite/TestSuite/Basics/BoundedList.hs view
@@ -20,7 +20,8 @@ import Data.SBV.Control import Utils.SBVTestFramework -import Data.SBV.List ((.:), (.!!))+import Prelude hiding ((!!))+import Data.SBV.List ((.:), (!!)) import qualified Data.SBV.List as L import qualified Data.SBV.Tools.BoundedList as BL @@ -172,7 +173,7 @@ mapWithFailure = do   lst <- sList "ints"   let (lst', failure) = runEval $ boundedIncr lst-  constrain $ lst' .!! 2 .> 11 .=> failure .== Failure sTrue+  constrain $ lst' !! 2 .> 11 .=> failure .== Failure sTrue  -- mapping over these values of a, b, and c cannot fail (this is unsat) mapNoFailure :: Symbolic ()
SBVTestSuite/TestSuite/Basics/Index.hs view
@@ -32,9 +32,9 @@ test1 :: Int -> IO Bool test1 n = isTheorem $ do             elts <- mkForallVars n-            err  <- forall_-            ind  <- forall_-            ind2 <- forall_+            err  <- sbvForall_+            ind  <- sbvForall_+            ind2 <- sbvForall_             let r1 = (select :: [SWord8] -> SWord8 -> SInt8 -> SWord8) elts err ind                 r2 = (select :: [SWord8] -> SWord8 -> SWord8 -> SWord8) elts err ind2                 r3 = slowSearch elts err ind@@ -49,11 +49,11 @@             elts1 <- mkForallVars n             elts2 <- mkForallVars n             let elts = zip elts1 elts2-            err1  <- forall_-            err2  <- forall_+            err1  <- sbvForall_+            err2  <- sbvForall_             let err = (err1, err2)-            ind  <- forall_-            ind2 <- forall_+            ind  <- sbvForall_+            ind2 <- sbvForall_             let r1 = (select :: [(SWord8, SWord8)] -> (SWord8, SWord8) -> SInt8 -> (SWord8, SWord8)) elts err ind                 r2 = (select :: [(SWord8, SWord8)] -> (SWord8, SWord8) -> SWord8 -> (SWord8, SWord8)) elts err ind2                 r3 = slowSearch elts err ind@@ -67,9 +67,9 @@ test3 n = isTheorem $ do             eltsI <- mkForallVars n             let elts = map Left eltsI-            errI  <- forall_+            errI  <- sbvForall_             let err = Left errI-            ind  <- forall_+            ind  <- sbvForall_             let r1 = (select :: [Either SWord8 SWord8] -> Either SWord8 SWord8 -> SInt8 -> Either SWord8 SWord8) elts err ind                 r2 = slowSearch elts err ind             return $ r1 .== r2
SBVTestSuite/TestSuite/Basics/IteTest.hs view
@@ -38,4 +38,4 @@     , testCase "iteTest6" (assertIsThm (chk3 iteLazy))     ]  where rs :: (SWord8 -> SBool) -> IO Result-       rs f = runSAT $ forAll ["x"] f+       rs f = runSAT $ universal ["x"] f
SBVTestSuite/TestSuite/Basics/List.hs view
@@ -7,7 +7,6 @@ -- Stability : experimental -- -- Test the sequence/list functions.--- Most of these tests are adopted from <http://rise4fun.com/z3/tutorialcontent/sequences> -----------------------------------------------------------------------------  {-# LANGUAGE OverloadedLists     #-}@@ -20,7 +19,10 @@ import Data.SBV.Control import Utils.SBVTestFramework -import Data.SBV.List ((.!!), (.++))+import           Prelude hiding ((++), (!!))+import qualified Prelude as P   ((++))++import Data.SBV.List ((!!), (++)) import qualified Data.SBV.List as L  import Control.Monad (unless)@@ -54,14 +56,14 @@                      case cs of                        Unsat  -> error "Failed! Expected Sat, got UNSAT"                        DSat{} -> error "Failed! Expected Sat, got delta-sat"-                       Sat    -> getModel         >>= \r -> error $ "Failed! Expected Unsat, got SAT:\n" ++ show (SatResult (Satisfiable cfg r))-                       Unk    -> getUnknownReason >>= \r -> error $ "Failed! Expected Unsat, got UNK:\n" ++ show r+                       Sat    -> getModel         >>= \r -> error $ "Failed! Expected Unsat, got SAT:\n" P.++ show (SatResult (Satisfiable cfg r))+                       Unk    -> getUnknownReason >>= \r -> error $ "Failed! Expected Unsat, got UNK:\n" P.++ show r  seqConcatSat :: Symbolic ()-seqConcatSat = constrain $ [1..3] .++ [4..6] .== ([1..6] :: SList Integer)+seqConcatSat = constrain $ [1..3] ++ [4..6] .== ([1..6] :: SList Integer)  seqConcatUnsat :: Symbolic ()-seqConcatUnsat = constrain $ [1..3] .++ [4..6] .== ([1..7] :: SList Integer)+seqConcatUnsat = constrain $ [1..3] ++ [4..6] .== ([1..7] :: SList Integer)  seqIndexOfSat :: Symbolic () seqIndexOfSat = constrain $ L.indexOf ([1,2,3,1,2,3] :: SList Integer) [1] .== 0@@ -72,40 +74,40 @@ -- Basic sequence operations seqExamples1 :: Symbolic () seqExamples1 = constrain $ sAnd-  [ L.singleton (([1,2,3] :: SList Integer) .!! 1) .++ L.singleton (([1,2,3] :: SList Integer) .!! 0) .== [2,1]-  , ([1,2,3,1,2,3] :: SList Integer) `L.indexOf` [1]                                                  .== 0-  , L.offsetIndexOf ([1,2,3,1,2,3] :: SList Integer) [1] 1                                            .== 3-  , L.subList ([4,4,1,2,3,5,5] :: SList Integer)     2 3                                              .== [1,2,3]+  [ L.singleton (([1,2,3] :: SList Integer) !! 1) ++ L.singleton (([1,2,3] :: SList Integer) !! 0) .== [2,1]+  , ([1,2,3,1,2,3] :: SList Integer) `L.indexOf` [1]                                               .== 0+  , L.offsetIndexOf ([1,2,3,1,2,3] :: SList Integer) [1] 1                                         .== 3+  , L.subList ([4,4,1,2,3,5,5] :: SList Integer)     2 3                                           .== [1,2,3]   ]  -- A list cannot overlap with two different elements seqExamples2 :: Symbolic () seqExamples2 = do   a :: SList Integer <- sList "a"-  constrain $ a .++ [2] .== [1] .++ a+  constrain $ a ++ [2] .== [1] ++ a  -- Strings a, b, c can have a non-trivial overlap. seqExamples3 :: Symbolic () seqExamples3 = do   [a, b, c :: SList Integer] <- sLists ["a", "b", "c"]-  constrain $ a .++ b .== [1..4]-  constrain $ b .++ c .== [3..6]+  constrain $ a ++ b .== [1..4]+  constrain $ b ++ c .== [3..6]   constrain $ sNot $ b .== []  -- There is a solution to a of length at most 2. seqExamples4 :: Symbolic () seqExamples4 = do   [a, b :: SList Integer] <- sLists ["a", "b"]-  constrain $ [1..3] .++ a .== b .++ [3..5]+  constrain $ [1..3] ++ a .== b ++ [3..5]   constrain $ L.length a .<= 2  -- There is a solution to a that is not a sequence of 1's. seqExamples5 :: Symbolic () seqExamples5 = do   [a, b, c :: SList Integer] <- sLists ["a", "b", "c"]-  constrain $ a .++ [1,2] .++ b .== b .++ [2,1] .++ c-  constrain $ c .== a .++ b-  constrain $ sNot $ a.++ [1] .== [1] .++ a+  constrain $ a ++ [1,2] ++ b .== b ++ [2,1] ++ c+  constrain $ c .== a ++ b+  constrain $ sNot $ a ++ [1] .== [1] ++ a  -- Contains is transitive. seqExamples6 :: Symbolic ()@@ -131,7 +133,7 @@   constrain $ b `L.isPrefixOf` a   constrain $ c `L.isSuffixOf` a   constrain $ L.length a .== L.length b + L.length c-  constrain $ sNot $ a .== b .++ c+  constrain $ sNot $ a .== b ++ c  -- Generate all length one sequences, to enumerate all and making sure we can parse correctly seqExamples9 :: IO Bool
SBVTestSuite/TestSuite/Basics/ModelValidate.hs view
@@ -6,7 +6,7 @@ -- Maintainer: erkokl@gmail.com -- Stability : experimental ----- Make sure the ABC bug is there, and a few other validate tests.+-- Few validate tests -----------------------------------------------------------------------------  {-# LANGUAGE ScopedTypeVariables #-}@@ -23,10 +23,10 @@ -- Test suite, this needs ABC testsABC :: TestTree testsABC = testGroup "Basics.ModelValidate.ABC" [-             goldenCapturedIO "validate_0" badABC+             goldenCapturedIO "validate_0" testABC            ]-    where badABC goldFile = do r <- satWith abc{verbose=True, redirectVerbose = Just goldFile, validateModel = True} $ forSome ["x"] $ \x -> x .< (10::SWord8)-                               appendFile goldFile ("\nFINAL OUTPUT:\n" ++ show r ++ "\n")+    where testABC goldFile = do r <- satWith abc{verbose=True, redirectVerbose = Just goldFile, validateModel = True} $ existential ["x"] $ \x -> x .< (10::SWord8)+                                appendFile goldFile ("\nFINAL OUTPUT:\n" ++ show r ++ "\n")  tests :: TestTree tests = testGroup "Basics.ModelValidate" [@@ -46,8 +46,8 @@                                `C.catch` (\(e::C.SomeException) -> appendFile goldFile ("\nEXCEPTION RAISED:\n" ++ pick (show e) ++ "\n"))               where pick s = unlines [l | l <- lines s, "***" `isPrefixOf` l] -          t1 = forSome ["x"] $ \x -> fpAdd sRTZ x x   .== (x::SFloat)-          t2 = forSome ["x"] $ \x -> fpFMA sRNE x x x .== (x::SFloat)+          t1 = existential ["x"] $ \x -> fpAdd sRTZ x x   .== (x::SFloat)+          t2 = existential ["x"] $ \x -> fpFMA sRNE x x x .== (x::SFloat)            t3 = do x <- sInteger "x"                   constrain $ x .> x@@ -58,6 +58,6 @@                   constrain $ x .> 12                   return $ x .== y+3 -          t5 = do x <- exists "x"-                  y <- forall "y"+          t5 = do x <- sbvExists "x"+                  y <- sbvForall "y"                   return $ fpIsPoint y .=> x .<= (y::SFloat)
SBVTestSuite/TestSuite/Basics/ProofTests.hs view
@@ -24,14 +24,14 @@     , testCase "proofs-4" (assertIsThm f1Single)     , testCase "proofs-5" (assertIsSat (f1 `xyEq` f2))     , testCase "proofs-6" (assertIsSat (f1 `xyEq` f3))-    , testCase "proofs-7" (assertIsntSat (exists "x" >>= \x -> return (x .== x + (1 :: SWord16))))-    , testCase "proofs-8" (assertIsSat (exists "x" >>= \x -> return (x :: SBool)))-    , testCase "proofs-9" (assertIsSat (exists "x" >>= \x -> return x :: Predicate))+    , testCase "proofs-7" (assertIsntSat (sbvExists "x" >>= \x -> return (x .== x + (1 :: SWord16))))+    , testCase "proofs-8" (assertIsSat (sbvExists "x" >>= \x -> return (x :: SBool)))+    , testCase "proofs-9" (assertIsSat (sbvExists "x" >>= \x -> return x :: Predicate))     ]  xyEq :: (EqSymbolic a, SymVal a1) => (SBV a1 -> SBV Word8 -> a) -> (SBV a1 -> SWord8 -> a) -> Symbolic SBool-func1 `xyEq` func2 = do x <- exists_-                        y <- exists_+func1 `xyEq` func2 = do x <- sbvExists_+                        y <- sbvExists_                         return $ func1 x y .== func2 x (y :: SWord8)  f1, f2, f3, f4 :: Num a => a -> a -> a@@ -41,13 +41,13 @@ f4 x y = x*x + 2*x*y + y*y  f1eqf2 :: Predicate-f1eqf2 = forAll_ $ \x y -> f1 x y .== f2 x (y :: SWord8)+f1eqf2 = universal_ $ \x y -> f1 x y .== f2 x (y :: SWord8)  f1eqf3 :: Predicate-f1eqf3 = forAll ["x", "y"] $ \x y -> f1 x y .== f3 x (y :: SWord8)+f1eqf3 = universal ["x", "y"] $ \x y -> f1 x y .== f3 x (y :: SWord8)  f3eqf4 :: Predicate-f3eqf4 = forAll_ $ \x y -> f3 x y .== f4 x (y :: SWord8)+f3eqf4 = universal_ $ \x y -> f3 x y .== f4 x (y :: SWord8)  f1Single :: Predicate-f1Single = forAll_ $ \x -> f1 x x .== (0 :: SWord16)+f1Single = universal_ $ \x -> f1 x x .== (0 :: SWord16)
SBVTestSuite/TestSuite/Basics/PseudoBoolean.hs view
@@ -9,7 +9,7 @@ -- Test the pseudo-boolean functions ----------------------------------------------------------------------------- -{-# OPTIONS_GHC -Wall -Werror #-}+{-# OPTIONS_GHC -Wall -Werror -Wno-incomplete-uni-patterns #-}  module TestSuite.Basics.PseudoBoolean(tests)  where
SBVTestSuite/TestSuite/Basics/Quantifiers.hs view
@@ -28,7 +28,7 @@                           , goldenCapturedIO ("quantified_prove" ++ "_" ++ nm) $ \rf -> void $ proveWith z3{verbose=True, redirectVerbose=Just rf} p                           ] -         qs   = [(exists, "exists"), (forall, "forall")]+         qs   = [(sbvExists, "exists"), (sbvForall, "forall")]           acts = [ (\x y -> x + (y - x) .== y  , "thm")                 , (\x y -> x .== y .&& x ./= y, "contradiction")
SBVTestSuite/TestSuite/Basics/Set.hs view
@@ -165,7 +165,7 @@ setOfTuples :: SMTConfig -> IO SatResult setOfTuples cfg = satWith cfg $ do     let x = tuple (empty :: SSet Bool, empty :: SSet Bool)-    y <- exists_+    y <- sbvExists_     return $ x ./= y  {-# ANN module ("HLint: ignore Reduce duplication" :: String) #-}
SBVTestSuite/TestSuite/Basics/String.hs view
@@ -7,7 +7,6 @@ -- Stability : experimental -- -- Test the string functions.--- Most of these tests are adopted from <http://rise4fun.com/z3/tutorialcontent/sequences> -----------------------------------------------------------------------------  {-# LANGUAGE OverloadedStrings #-}@@ -19,7 +18,10 @@ import Data.SBV.Control import Utils.SBVTestFramework -import Data.SBV.String ((.!!), (.++))+import Prelude hiding ((!!), (++))+import qualified Prelude as P ((++))++import Data.SBV.String ((!!), (++)) import qualified Data.SBV.String as S import qualified Data.SBV.Char   as SC import qualified Data.SBV.RegExp as R@@ -63,14 +65,14 @@                      case cs of                        Unsat  -> error "Failed! Expected Sat, got UNSAT"                        DSat{} -> error "Failed! Expected Sat, got delta-sat"-                       Sat    -> getModel         >>= \r -> error $ "Failed! Expected Unsat, got SAT:\n" ++ show (SatResult (Satisfiable cfg r))-                       Unk    -> getUnknownReason >>= \r -> error $ "Failed! Expected Unsat, got UNK:\n" ++ show r+                       Sat    -> getModel         >>= \r -> error $ "Failed! Expected Unsat, got SAT:\n" P.++ show (SatResult (Satisfiable cfg r))+                       Unk    -> getUnknownReason >>= \r -> error $ "Failed! Expected Unsat, got UNK:\n" P.++ show r  strConcatSat :: Symbolic ()-strConcatSat = constrain $ "abc" .++ "def" .== "abcdef"+strConcatSat = constrain $ "abc" ++ "def" .== "abcdef"  strConcatUnsat :: Symbolic ()-strConcatUnsat = constrain $ "abc" .++ "def" .== "abcdefg"+strConcatUnsat = constrain $ "abc" ++ "def" .== "abcdefg"  strIndexOfSat :: Symbolic () strIndexOfSat = constrain $ S.indexOf "abcabc" "a" .== 0@@ -81,40 +83,40 @@ -- Basic string operations strExamples1 :: Symbolic () strExamples1 = constrain $ sAnd-  [ S.singleton ("abc" .!! 1) .++ S.singleton ("abc" .!! 0) .== "ba"-  , "abcabc" `S.indexOf` "a"                                .== 0-  , S.offsetIndexOf "abcabc" "a" 1                          .== 3-  , S.subStr "xxabcyy" 2 3                                  .== "abc"+  [ S.singleton ("abc" !! 1) ++ S.singleton ("abc" !! 0) .== "ba"+  , "abcabc" `S.indexOf` "a"                              .== 0+  , S.offsetIndexOf "abcabc" "a" 1                        .== 3+  , S.subStr "xxabcyy" 2 3                                .== "abc"   ]  -- A string cannot overlap with two different characters. strExamples2 :: Symbolic () strExamples2 = do   a <- sString "a"-  constrain $ a .++ "b" .== "a" .++ a+  constrain $ a ++ "b" .== "a" ++ a  -- Strings a, b, c can have a non-trivial overlap. strExamples3 :: Symbolic () strExamples3 = do   [a, b, c] <- sStrings ["a", "b", "c"]-  constrain $ a .++ b .== "abcd"-  constrain $ b .++ c .== "cdef"+  constrain $ a ++ b .== "abcd"+  constrain $ b ++ c .== "cdef"   constrain $ sNot $ b .== ""  -- There is a solution to a of length at most 2. strExamples4 :: Symbolic () strExamples4 = do   [a, b] <- sStrings ["a", "b"]-  constrain $ "abc" .++ a .== b .++ "cef"+  constrain $ "abc" ++ a .== b ++ "cef"   constrain $ S.length a .<= 2  -- There is a solution to a that is not a sequence of "a"'s. strExamples5 :: Symbolic () strExamples5 = do   [a, b, c] <- sStrings ["a", "b", "c"]-  constrain $ a .++ "ab" .++ b .== b .++ "ba" .++ c-  constrain $ c .== a .++ b-  constrain $ sNot $ a.++ "a" .== "a" .++ a+  constrain $ a ++ "ab" ++ b .== b ++ "ba" ++ c+  constrain $ c .== a ++ b+  constrain $ sNot $ a ++ "a" .== "a" ++ a  -- Contains is transitive. strExamples6 :: Symbolic ()@@ -140,7 +142,7 @@   constrain $ b `S.isPrefixOf` a   constrain $ c `S.isSuffixOf` a   constrain $ S.length a .== S.length b + S.length c-  constrain $ sNot $ a .== b .++ c+  constrain $ sNot $ a .== b ++ c  -- The maximal length is 6 for a string of length 2 repeated at most 3 times strExamples9 :: Symbolic ()
SBVTestSuite/TestSuite/Basics/Tuple.hs view
@@ -21,8 +21,10 @@  module TestSuite.Basics.Tuple (tests)  where +import Prelude hiding ((!!))+ import Data.SBV.Control-import Data.SBV.List ((.!!), (.:))+import Data.SBV.List ((!!), (.:)) import Data.SBV.Tuple  import qualified Data.SBV.List as L@@ -85,11 +87,11 @@ list = do   lst <- sList @(Integer, [(Integer, String)]) "lst" -  constrain $ (lst .!! 0)^._1 .== 2-  constrain $ (((lst .!! 1)^._2) .!! 0)^._2 .== literal "foo"+  constrain $ (lst !! 0)^._1 .== 2+  constrain $ (((lst !! 1)^._2) !! 0)^._2 .== literal "foo"   constrain $ L.length lst .== 4-  constrain $ L.length ((lst .!! 1)^._2) .== 5-  constrain $ L.length ((lst .!! 2)^._2) .== 0+  constrain $ L.length ((lst !! 1)^._2) .== 5+  constrain $ L.length ((lst !! 2)^._2) .== 0    constrain $ lst .== literal [(2,[]), (1,[(3,"foo"), (0,"bar"), (-1,"baz"), (-2,"quux"), (-3,"enough")]), (-4,[]), (-5,[])] @@ -101,13 +103,13 @@    vTup1 :: SList (E, [Bool]) <- sList "v1"    q <- sBool "q"    constrain $ sNot q-   constrain $ (vTup1 .!! 1)^._2 .== sTrue .: q .: L.nil+   constrain $ (vTup1 !! 1)^._2 .== sTrue .: q .: L.nil    constrain $ L.length vTup1 .== 3 -   case untuple (vTup1 .!! 2)  of+   case untuple (vTup1 !! 2)  of      (e, b) -> do constrain $ e .== sC                   constrain $ L.length b .== 6-                  constrain $ b .!! 4 .== sTrue+                  constrain $ b !! 4 .== sTrue     query $ do      vTup2 :: STuple Word8 (E, Char, Float) <- freshVar "v2"
SBVTestSuite/TestSuite/CRC/CCITT.hs view
@@ -27,7 +27,7 @@   [ goldenVsStringShow "ccitt" crcPgm   , testCase "ccit_good" (assertIsThm crcGood)   ]-  where crcPgm = runSAT $ forAll_ crcGood >>= output+  where crcPgm = runSAT $ universal_ crcGood >>= output  extendData :: SWord 48 -> SWord 64 extendData msg = fromBitsBE $ blastBE msg ++ replicate 16 sFalse
SBVTestSuite/TestSuite/CRC/GenPoly.hs view
@@ -31,8 +31,8 @@  crcGoodE :: Symbolic SBool crcGoodE = do-  x <- exists_-  y <- exists_+  x <- sbvExists_+  y <- sbvExists_   return (crcGood 3 0 x y)  extendData :: SWord 48 -> SWord 64
SBVTestSuite/TestSuite/Char/Char.hs view
@@ -98,7 +98,7 @@ t10 :: Symbolic () t10 = do x :: SList ((Char, Char), [Integer]) <- free "x"          constrain $ L.length x .== 1-         constrain $ (x L..!! 0)^._1^._1 .== literal 'B'+         constrain $ (x L.!! 0)^._1^._1 .== literal 'B'  cf4 :: SInteger -> SChar -> SList ((Char, Char), [Integer]) cf4 = uninterpret "cf4"
SBVTestSuite/TestSuite/Existentials/CRCPolynomial.hs view
@@ -25,7 +25,7 @@  ]  pgm :: Predicate-pgm = do p <- exists "poly"-         s <- forall "sent"-         r <- forall "received"+pgm = do p <- sbvExists "poly"+         s <- sbvForall "sent"+         r <- sbvForall "received"          return $ sTestBit p 0 .&& crcGood 4 p s r
SBVTestSuite/TestSuite/Optimization/Quantified.hs view
@@ -6,7 +6,7 @@ -- Maintainer: erkokl@gmail.com -- Stability : experimental ----- Test suite for optimization iwth quantifiers+-- Test suite for optimization with quantifiers -----------------------------------------------------------------------------  {-# OPTIONS_GHC -Wall -Werror #-}@@ -38,7 +38,7 @@ q1 :: Goal q1 = do a <- sInteger "a"         [b1, b2] <- sIntegers ["b1", "b2"]-        x <- forall "x" :: Symbolic SInteger+        x <- sbvForall "x" :: Symbolic SInteger         constrain $ 2 * (a * x + b1) .== 2         constrain $ 4 * (a * x + b2) .== 4         constrain $ a .>= 0@@ -47,7 +47,7 @@ q2 :: Goal q2 = do a <- sInteger "a"         [b1, b2] <- sIntegers ["b1", "b2"]-        x <- forall "x" :: Symbolic SInteger+        x <- sbvForall "x" :: Symbolic SInteger         constrain $ 2 * (a * x + b1) .== 2         constrain $ 4 * (a * x + b2) .== 4         constrain $ a .>= 0@@ -57,7 +57,7 @@ q3 = do a <- sInteger "a"         [b1, b2] <- sIntegers ["b1", "b2"]         minimize "goal" a-        x <- forall "x" :: Symbolic SInteger+        x <- sbvForall "x" :: Symbolic SInteger         constrain $ 2 * (a * x + b1) .== 2         constrain $ 4 * (a * x + b2) .== 4         constrain $ a .>= 0@@ -66,15 +66,15 @@ q4 = do a <- sInteger "a"         [b1, b2] <- sIntegers ["b1", "b2"]         minimize "goal" $ 2*a-        x <- forall "x" :: Symbolic SInteger+        x <- sbvForall "x" :: Symbolic SInteger         constrain $ 2 * (a * x + b1) .== 2         constrain $ 4 * (a * x + b2) .== 4         constrain $ a .>= 0  q5 :: Goal q5 = do a <- sInteger "a"-        x <- forall "x" :: Symbolic SInteger-        y <- forall "y" :: Symbolic SInteger+        x <- sbvForall "x" :: Symbolic SInteger+        y <- sbvForall "y" :: Symbolic SInteger         b <- sInteger "b"         constrain $ a .>= 0         constrain $ b .>= 0
SBVTestSuite/TestSuite/Overflows/Arithmetic.hs view
@@ -132,21 +132,16 @@ exactlyWhen :: SBool -> SVal -> SBool exactlyWhen (SBV a) b = SBV $ (a `svAnd` b) `svOr` (svNot a `svAnd` svNot b) --- Properly extend to a dynamic large vector+-- Properly extend to a dynamic signed large vector. This works because we grow to 256 bits, which is high enough. toLarge :: HasKind a => SBV a -> SLarge toLarge v   | extra < 0 = error $ "toLarge: Unexpected size: " ++ show (n, large)-  | hasSign v = p `svJoin` dv-  | True      = z `svJoin` dv+  | hasSign v =            svSignExtend extra (unSBV v)+  | True      = mkSigned $ svZeroExtend extra (unSBV v)   where n     = intSizeOf v         extra = large - n -        dv    = unSBV v-        mk    = svInteger (KBounded True extra)-        z     = mk 0-        o     = mk (-1)-        pos   = (dv `svTestBit` (n-1)) `svEqual` svFalse-        p     = svIte pos z o+        mkSigned = svFromIntegral (KBounded True large)  -- Multiplication checks are expensive. For these, we simply check that the SBV encodings and the z3 versions are equivalent mulChkO :: forall a. SymVal a => (SBV a -> SBV a -> (SBool, SBool)) -> (SBV a -> SBV a -> (SBool, SBool)) -> Predicate@@ -210,7 +205,6 @@                             extResult :: SLarge                            extResult = toLarge x `op` toLarge y-                         return $ underflowHappens `exactlyWhen` (extResult `svLessThan` toLarge (minBound :: SBV a))
SBVTestSuite/TestSuite/Puzzles/Counts.hs view
@@ -22,5 +22,5 @@ tests = testGroup "Puzzles.Counts" [   goldenVsStringShow "counts" countPgm  ]- where countPgm = runSAT $ forAll_ puzzle' >>= output+ where countPgm = runSAT $ universal_ puzzle' >>= output        puzzle' d0 d1 d2 d3 d4 d5 d6 d7 d8 d9 = puzzle [d0, d1, d2, d3, d4, d5, d6, d7, d8, d9]
SBVTestSuite/TestSuite/Puzzles/Temperature.hs view
@@ -24,7 +24,7 @@   testGroup "Puzzles.Temperature"     [ goldenVsStringShow "temperature" result     ]-    where result = (sort . concatMap M.toList . getModelDictionaries) `fmap` allSat (revOf `fmap` exists_)+    where result = (sort . concatMap M.toList . getModelDictionaries) `fmap` allSat (revOf `fmap` sbvExists_)  type Temp = SInteger
SBVTestSuite/TestSuite/Puzzles/U2Bridge.hs view
@@ -30,7 +30,7 @@     , testCase "U2Bridge_cnt6" (assert $ (0 ==) `fmap` count 6)     , goldenVsStringShow "U2Bridge" (slv 5)     ]- where act     = do b <- exists_; p1 <- exists_; p2 <- exists_; return (b, p1, p2)+ where act     = do b <- sbvExists_; p1 <- sbvExists_; p2 <- sbvExists_; return (b, p1, p2)        count n = numberOfModels $ isValid `fmap` mapM (const act) [1..(n::Int)]        slv n   = rearrange `fmap` allSat (isValid `fmap` mapM (const act) [1..(n::Int)])
SBVTestSuite/Utils/SBVTestFramework.hs view
@@ -22,9 +22,7 @@         , goldenString         , goldenVsStringShow         , goldenCapturedIO-        , CIOS(..), TestEnvironment(..), getTestEnvironment         , qc1, qc2-        , pickTests         -- module exports to simplify life         , module Test.Tasty         , module Test.Tasty.HUnit@@ -38,7 +36,6 @@ import qualified Data.ByteString.Lazy.Char8 as LBC  import System.Directory   (removeFile)-import System.Environment (lookupEnv)  import Test.Tasty            (testGroup, TestTree, TestName) import Test.Tasty.HUnit      ((@?), Assertion, testCase, AssertionPredicable)@@ -49,51 +46,16 @@ import qualified Test.QuickCheck.Monadic as QC  import Test.Tasty.Runners hiding (Result)-import System.Random (randomRIO)  import Data.SBV import Data.SBV.Control -import Data.Char  (isDigit)-import Data.Maybe (fromMaybe, catMaybes)+import Data.Maybe (fromMaybe)  import System.FilePath ((</>), (<.>))  import Data.SBV.Internals (runSymbolic, Result, SBVRunMode(..), IStage(..), SBV(..), SVal(..), showModel, SMTModel(..), QueryContext(..)) ------------------------------------------------------------------------------------------- Test environment; continuous integration-data CIOS = CILinux-          | CIOSX-          | CIWindows-          deriving (Show, Eq)--data TestEnvironment = TestEnvLocal-                     | TestEnvCI CIOS-                     | TestEnvUnknown-                     deriving Show--getTestEnvironment :: IO (TestEnvironment, Int)-getTestEnvironment = do mbTestEnv  <- lookupEnv "SBV_TEST_ENVIRONMENT"-                        mbTestPerc <- lookupEnv "SBV_HEAVYTEST_PERCENTAGE"--                        env <- case mbTestEnv of-                                 Just "local" -> return   TestEnvLocal-                                 Just "linux" -> return $ TestEnvCI CILinux-                                 Just "osx"   -> return $ TestEnvCI CIOSX-                                 Just "win"   -> return $ TestEnvCI CIWindows-                                 Just other   -> do putStrLn $ "Ignoring unexpected test env value: " ++ show other-                                                    return TestEnvUnknown-                                 Nothing      -> return TestEnvUnknown--                        perc <- case mbTestPerc of-                                 Just n | all isDigit n -> return (read n)-                                 Just n                 -> do putStrLn $ "Ignoring unexpected test percentage value: " ++ show n-                                                              return 100-                                 Nothing                -> return 100--                        return (env, perc)- -- | Generic assertion. This is less safe than usual, but will do. assert :: AssertionPredicable t => t -> Assertion assert t = t @? "assertion-failure"@@ -266,20 +228,5 @@                         case result of                            Right a -> QC.assert $ expected == a                            _       -> QC.assert False---- | Picking a certain percent of tests.-pickTests :: Int -> TestTree -> IO TestTree-pickTests d origTests = fromMaybe noTestsSelected <$> walk origTests-   where noTestsSelected = TestGroup "pickTests.NoTestsSelected" []--         walk t@SingleTest{}    = do c <- randomRIO (0, 99)-                                     if c < d-                                        then return $ Just t-                                        else return Nothing-         walk (TestGroup tn ts) = do cs <- catMaybes <$> mapM walk ts-                                     case cs of-                                       [] -> return Nothing-                                       _  -> return $ Just $ TestGroup tn cs-         walk _                 = error "pickTests: Unexpected test group!"  {-# ANN module ("HLint: ignore Reduce duplication" :: String) #-}
sbv.cabal view
@@ -1,7 +1,7 @@ Cabal-Version: 2.2  Name        : sbv-Version     : 8.17+Version     : 9.0 Category    : Formal Methods, Theorem Provers, Bit vectors, Symbolic Computation, Math, SMT Synopsis    : SMT Based Verification: Symbolic Haskell theorem prover using SMT solving. Description : Express properties about Haskell programs and automatically prove them using SMT@@ -9,7 +9,7 @@                .                For details, please see: <http://leventerkok.github.io/sbv/> -Copyright          : Levent Erkok, 2010-2021+Copyright          : Levent Erkok, 2010-2022 License            : BSD-3-Clause License-file       : LICENSE Stability          : Experimental@@ -21,7 +21,7 @@ Data-Files         : SBVTestSuite/GoldFiles/*.gold Extra-Source-Files : INSTALL, README.md, COPYRIGHT, CHANGES.md -Tested-With        : GHC==9.0.1+Tested-With        : GHC==9.2.1  source-repository head     type:       git@@ -37,6 +37,7 @@  Library   import          : common-settings+  default-language: Haskell2010   other-extensions: BangPatterns                     CPP                     ConstraintKinds@@ -125,6 +126,8 @@                   , Documentation.SBV.Examples.Lists.Fibonacci                   , Documentation.SBV.Examples.Lists.Nested                   , Documentation.SBV.Examples.Lists.BoundedMutex+                  , Documentation.SBV.Examples.Lists.CountOutAndTransfer+                  , Documentation.SBV.Examples.Misc.Definitions                   , Documentation.SBV.Examples.Misc.Enumerate                   , Documentation.SBV.Examples.Misc.Floating                   , Documentation.SBV.Examples.Misc.ModelExtract@@ -153,14 +156,17 @@                   , Documentation.SBV.Examples.WeakestPreconditions.IntSqrt                   , Documentation.SBV.Examples.WeakestPreconditions.Length                   , Documentation.SBV.Examples.WeakestPreconditions.Sum+                  , Documentation.SBV.Examples.Puzzles.AOC_2021_24                   , Documentation.SBV.Examples.Puzzles.Birthday                   , Documentation.SBV.Examples.Puzzles.Coins                   , Documentation.SBV.Examples.Puzzles.Counts                   , Documentation.SBV.Examples.Puzzles.DogCatMouse+                  , Documentation.SBV.Examples.Puzzles.Drinker                   , Documentation.SBV.Examples.Puzzles.Euler185                   , Documentation.SBV.Examples.Puzzles.Fish                   , Documentation.SBV.Examples.Puzzles.Garden                   , Documentation.SBV.Examples.Puzzles.HexPuzzle+                  , Documentation.SBV.Examples.Puzzles.Jugs                   , Documentation.SBV.Examples.Puzzles.LadyAndTigers                   , Documentation.SBV.Examples.Puzzles.MagicSquare                   , Documentation.SBV.Examples.Puzzles.Murder@@ -229,6 +235,7 @@  Test-Suite SBVTest   import           : common-settings+  default-language : Haskell2010   type             : exitcode-stdio-1.0   ghc-options      : -with-rtsopts=-K64m   other-extensions : DataKinds@@ -358,6 +365,7 @@  Test-Suite SBVConnections     import          : common-settings+    default-language: Haskell2010     build-depends   : sbv     hs-source-dirs  : SBVTestSuite     main-is         : SBVConnectionTest.hs@@ -365,8 +373,9 @@  Test-Suite SBVDocTest     import          : common-settings-    build-depends   : base, directory, filepath, random-                    , doctest, Glob, bytestring, tasty, tasty-golden, tasty-hunit, tasty-quickcheck, mtl, QuickCheck, random, sbv+    default-language: Haskell2010+    build-depends   : base, sbv, process, QuickCheck, filepath, mtl, bytestring, directory+                    , tasty, tasty-quickcheck, tasty-golden, tasty-hunit     other-extensions: DataKinds                       DeriveAnyClass                       DeriveDataTypeable@@ -388,8 +397,9 @@  Test-Suite SBVHLint     import          : common-settings+    default-language: Haskell2010 -    build-depends   : base, directory, filepath, random+    build-depends   : base, directory, filepath                     , hlint, bytestring, tasty, tasty-golden, tasty-hunit, tasty-quickcheck, mtl, QuickCheck, sbv     other-extensions: DataKinds                       DeriveAnyClass@@ -410,112 +420,9 @@     main-is         : SBVHLint.hs     type            : exitcode-stdio-1.0 -Benchmark SBVBenchmark-  import          : common-settings-  type            : exitcode-stdio-1.0-  ghc-options     : -with-rtsopts=-K64m-  other-extensions: DataKinds-                    DeriveAnyClass-                    DeriveDataTypeable-                    FlexibleContexts-                    GeneralizedNewtypeDeriving-                    OverloadedLists-                    OverloadedStrings-                    Rank2Types-                    RankNTypes-                    ScopedTypeVariables-                    StandaloneDeriving-                    TemplateHaskell-                    TupleSections-                    TypeApplications-  build-depends   : filepath, syb, text, sbv, directory, random, mtl, containers, time-                  , gauge, process, deepseq, bench-show, silently-  hs-source-dirs  : SBVBenchSuite-  main-is         : SBVBenchmark.hs-  other-modules   : Utils.SBVBenchFramework-                  , BenchSuite.Bench.Bench-                  , BenchSuite.Puzzles.Birthday-                  , BenchSuite.Puzzles.Coins-                  , BenchSuite.Puzzles.Counts-                  , BenchSuite.Puzzles.DogCatMouse-                  , BenchSuite.Puzzles.Euler185-                  , BenchSuite.Puzzles.Garden-                  , BenchSuite.Puzzles.LadyAndTigers-                  , BenchSuite.Puzzles.MagicSquare-                  , BenchSuite.Puzzles.NQueens-                  , BenchSuite.Puzzles.SendMoreMoney-                  , BenchSuite.Puzzles.Sudoku-                  , BenchSuite.Puzzles.U2Bridge-                  , BenchSuite.BitPrecise.BitTricks-                  , BenchSuite.BitPrecise.BrokenSearch-                  , BenchSuite.BitPrecise.Legato-                  , BenchSuite.BitPrecise.MergeSort-                  , BenchSuite.BitPrecise.MultMask-                  , BenchSuite.BitPrecise.PrefixSum-                  , BenchSuite.Queries.AllSat-                  , BenchSuite.Queries.CaseSplit-                  , BenchSuite.Queries.Concurrency-                  , BenchSuite.Queries.Enums-                  , BenchSuite.Queries.FourFours-                  , BenchSuite.Queries.GuessNumber-                  , BenchSuite.Queries.Interpolants-                  , BenchSuite.Queries.UnsatCore-                  , BenchSuite.WeakestPreconditions.Instances-                  , BenchSuite.WeakestPreconditions.Append-                  , BenchSuite.WeakestPreconditions.Basics-                  , BenchSuite.WeakestPreconditions.Fib-                  , BenchSuite.WeakestPreconditions.GCD-                  , BenchSuite.WeakestPreconditions.IntDiv-                  , BenchSuite.WeakestPreconditions.IntSqrt-                  , BenchSuite.WeakestPreconditions.Length-                  , BenchSuite.WeakestPreconditions.Sum-                  , BenchSuite.Optimization.Instances-                  , BenchSuite.Optimization.Enumerate-                  , BenchSuite.Optimization.ExtField-                  , BenchSuite.Optimization.LinearOpt-                  , BenchSuite.Optimization.Production-                  , BenchSuite.Optimization.VM-                  , BenchSuite.Uninterpreted.AUF-                  , BenchSuite.Uninterpreted.Deduce-                  , BenchSuite.Uninterpreted.Function-                  , BenchSuite.Uninterpreted.Multiply-                  , BenchSuite.Uninterpreted.Shannon-                  , BenchSuite.Uninterpreted.Sort-                  , BenchSuite.Uninterpreted.UISortAllSat-                  , BenchSuite.ProofTools.BMC-                  , BenchSuite.ProofTools.Fibonacci-                  , BenchSuite.ProofTools.Strengthen-                  , BenchSuite.ProofTools.Sum-                  , BenchSuite.CodeGeneration.AddSub-                  , BenchSuite.CodeGeneration.CRC_USB5-                  , BenchSuite.CodeGeneration.Fibonacci-                  , BenchSuite.CodeGeneration.GCD-                  , BenchSuite.CodeGeneration.PopulationCount-                  , BenchSuite.CodeGeneration.Uninterpreted-                  , BenchSuite.Crypto.AES-                  , BenchSuite.Crypto.RC4-                  , BenchSuite.Crypto.SHA-                  , BenchSuite.Misc.Auxiliary-                  , BenchSuite.Misc.Enumerate-                  , BenchSuite.Misc.Floating-                  , BenchSuite.Misc.ModelExtract-                  , BenchSuite.Misc.Newtypes-                  , BenchSuite.Misc.NoDiv0-                  , BenchSuite.Misc.Polynomials-                  , BenchSuite.Misc.SetAlgebra-                  , BenchSuite.Misc.SoftConstrain-                  , BenchSuite.Misc.Tuple-                  , BenchSuite.Lists.BoundedMutex-                  , BenchSuite.Lists.Fibonacci-                  , BenchSuite.Lists.Nested-                  , BenchSuite.Strings.RegexCrossword-                  , BenchSuite.Strings.SQLInjection-                  , BenchSuite.Existentials.CRCPolynomial-                  , BenchSuite.Existentials.Diophantine-                  , BenchSuite.Transformers.SymbolicEval- Benchmark SBVBench   import          : common-settings+  default-language: Haskell2010   type            : exitcode-stdio-1.0   ghc-options     : -with-rtsopts=-K64m   other-extensions: DataKinds@@ -532,8 +439,7 @@                     TemplateHaskell                     TupleSections                     TypeApplications-  build-depends   : filepath, syb, text, sbv, directory, random, mtl, containers, time-                  , gauge, process, deepseq, silently, bench-show+  build-depends   : filepath, sbv, random, time , process, deepseq, tasty, tasty-bench   hs-source-dirs  : SBVBenchSuite   main-is         : SBVBench.hs   other-modules   : Utils.SBVBenchFramework