packages feed

sbv 10.2 → 10.3

raw patch · 185 files changed

+39198/−41501 lines, 185 filesdep ~asyncdep ~basedep ~libBF

Dependency ranges changed: async, base, libBF

Files

CHANGES.md view
@@ -1,8 +1,58 @@ * Hackage: <http://hackage.haskell.org/package/sbv> * GitHub:  <http://leventerkok.github.io/sbv/> -* Latest Hackage released version: 10.2, 2023-06-09+* Latest Hackage released version: 10.3, 2024-01-05 +### Version 10.3, 2024-01-05++  * Clean-up GHC extensions required in the cabal file, and changes required to compile cleanly with GHC 9.8 series.++  * Added 'partition', which allows for partitioning all-sat search spaces when models are generated.++  * Added 'sSetBitTo', variant of 'setBitTo', but allows symbolic indexes.++  * Added 'uninterpretWithArgs', which allows for user given argument names for uninterpreted functions. These+    names come in handy when displaying models of uninterpreted functions.++  * Added `Documentation.SBV.Examples.Misc.ProgramPaths`, showing an example use of all-sat partitioning.++  * Added `Documentation.SBV.Examples.BitPrecise.PEXT_PDEP`, modeling x86 instructions PDEP and PEXT.++  * Added `Documentation.SBV.Examples.Puzzles.Newspaper`, another puzzle example.++  * Added `Documentation.SBV.Examples.ProofTools.AddHorn`, demonstrating the use of the horn-clause solver for+    invariant generation.++  * Add 'sbv2smt', which renders the given sbv definition as an SMTLib definition. Mainly useful for debugging purposes.+    It can render both ground definitions and functions, and the latter can be handy in producing SMTLib functions to+    be used in other settings.++  * Add support for OpenSMT from Università della Svizzera italiana https://verify.inf.usi.ch/opensmt++  * Fix a bug in bit-vector rotation that manifested itself in small-bv sizes. Thanks to Sirui Lu for reporting.++  * [BACKWARDS COMPATIBILITY] Change the overflow detection API to match the new SMTLib predicates. These predicates+    do not distinguish between over/underflow, so strictly speaking the new API is less powerful than the old one. However,+    we choose to follow SMTLib here for portability purposes. If you need separate overflow/underflow checking you can+    use the encodings from earlier implementations, please get in touch if this proves problematic.++  * [BACKWARDS COMPATIBILITY] Dropped hasSize, which checked cardinality of sets. This call hasn't been supported by+    z3 for some time, and its uses were thus limited, and behavior was problematic even when supported due to finiteness+    issues.++  * Removed a few examples, which were causing regression failures with changes in z3. These are trickier examples, and+    new releases of z3 had varying performance issues, making them not suitable regression and documentation purposes. In+    particular, 'Documentation.SBV.Examples.Existentials.CRCPolynomial', 'Documentation.SBV.Examples.Lists.Nested', and+    'Documentation.SBV.Examples.BitPrecise.MultMask' were removed.++  * SBV now keeps track of contexts, thus avoiding rare (but unsound) cases of incorrect API usage where contexts+    are mixed. We now issue a run-time error. See https://github.com/LeventErkok/sbv/issues/71 for details.++  * Improve the getFunction signature, to return more detailed info on the produced SMT functions, including the parse-tree.++  * SBV now tracks whether a declared uninterpreted function is curried or not. This helps in more precise printing of+    satisfying models with uninterpreted functions. (Previously all UI functions were displayed as if they were curried.)+ ### Version 10.2, 2023-06-09    * Improve HLint pragmas. Thanks to George Thomas for the patch.@@ -123,7 +173,7 @@   * Handle uninterpreted sorts better, avoiding kind-registration issue.     See #634 for details. Thanks to Nick Lewchenko for the report. -### Version 9.1, Released, 2023-01-09+### Version 9.1, 2023-01-09    * CVC5: Add support for algebraic reals in CVC5 models @@ -1062,7 +1112,7 @@     'sAssert' calls were run in the context of the final output boolean,     which is simply the wrong thing to do. -### Version 7.8, Released 2018-05-18+### Version 7.8, 2018-05-18    * Fix printing of min-bounds for signed 32/64 bit numbers in C     code generation: These are tricky since C does not allow@@ -1098,7 +1148,7 @@     showing how to code cover properties using SBV, using a form     of bounded model checking. -### Version 7.7, Released 2018-04-29+### Version 7.7, 2018-04-29    * Add support for Symbolic characters ('SChar') and strings ('SString'.)     Thanks to Joel Burget for the initial implementation.@@ -1154,7 +1204,7 @@     reals from the Internals module for further user processing.     Thanks  to Jan Path for the patch. -### Version 7.6, Released 2018-03-18+### Version 7.6, 2018-03-18    * GHC 8.4.1 compatibility: Work around compilation issues. SBV     now compiles cleanly with GHC 8.4.1.@@ -1164,7 +1214,7 @@     bit sizes. These are similar to sWord8, sInt8, etc.; except     they create dynamic counterparts that can be of arbitrary bit size. -### Version 7.5, Released 2018-01-13+### Version 7.5, 2018-01-13    * Remove obsolete references to tactics in a few haddock comments. Thanks     to Matthew Pickering for reporting.@@ -2020,7 +2070,7 @@ ### Version 4.1, 2015-03-06    * Add support for the ABC solver from Berkeley. Thanks to Adam Foltzer-    for the required infrastructure! See: http://www.eecs.berkeley.edu/~alanmi/abc/+    for the required infrastructure! See: https://github.com/berkeley-abc/abc     And Alan Mishchenko for adding infrastructure to ABC to work with SBV.    * Upgrade the Boolector connection to use a SMT-Lib2 based interaction. NB. You
@@ -1,4 +1,4 @@-Copyright (c) 2010-2023, Levent Erkok (erkokl@gmail.com)+Copyright (c) 2010-2024, 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
@@ -131,6 +131,8 @@ -- --   * DReal from CMU: <http://dreal.github.io/> --+--   * OpenSMT from Università della Svizzera italiana <https://verify.inf.usi.ch/opensmt>+-- --   * Z3 from Microsoft: <http://github.com/Z3Prover/z3/wiki> -- -- SBV requires recent versions of these solvers; please see the file@@ -329,6 +331,9 @@   , satWithAny,   satWithAll,   satConcurrentWithAny,   satConcurrentWithAll   , generateSMTBenchmarkSat, generateSMTBenchmarkProof   , solve+  -- ** Partitioning result space+  -- $partitionIntro+  , partition    -- * Constraints and Quantifiers   -- $constrainIntro@@ -399,7 +404,7 @@   -- $verbosity    -- ** Solvers-  , boolector, bitwuzla, cvc4, cvc5, yices, dReal, z3, mathSAT, abc+  , boolector, bitwuzla, cvc4, cvc5, yices, dReal, z3, mathSAT, abc, openSMT   -- ** Configurations   , defaultSolverConfig, defaultSMTCfg, defaultDeltaSMTCfg, sbvCheckSolverInstallation, getAvailableSolvers   , setLogic, Logic(..), setOption, setInfo, setTimeOut@@ -771,7 +776,7 @@     * Extraction and concatenation: 'bvExtract', '#', 'zeroExtend', 'signExtend', 'bvDrop', and 'bvTake' -Usual arithmetic ('+', '-', '*', 'sQuotRem', 'sQuot', 'sRem', 'sDivMod', 'sDiv', 'sMod') and logical operations ('.<', '.<=', '.>', '.>=', '.==', './=') operations are+Usual arithmetic ('Prelude.+', 'Prelude.-', '*', 'sQuotRem', 'sQuot', 'sRem', 'sDivMod', 'sDiv', 'sMod') and logical operations ('.<', '.<=', '.>', '.>=', '.==', './=') operations are supported for 'SInteger' fully, both in programming and verification modes. -} @@ -817,6 +822,67 @@ specialized type-signatures since Haskell insists on an 'Int' second argument for them. -} +{- $partitionIntro+The function 'partition' allows one to restrict the results returned by calls to 'Data.SBV.allSat'.+In certain cases, we might consider certain models to be "equivalent," i.e., we might want to+create equivalence classes over the search space when it comes to what we consider all satisfying+solutions. In these cases, we can use 'partition' to tell SBV what classes of solutions to consider+as unique. Consider:++>>> :{+allSat $ do+   x <- sInteger "x"+   y <- sInteger "y"+   partition "p1" $ x .>= 0+   partition "p2" $ y .>= 0+:}+Solution #1:+  x  =     0 :: Integer+  y  =    -1 :: Integer+  p1 =  True :: Bool+  p2 = False :: Bool+Solution #2:+  x  =    -1 :: Integer+  y  =     0 :: Integer+  p1 = False :: Bool+  p2 =  True :: Bool+Solution #3:+  x  =    -1 :: Integer+  y  =    -1 :: Integer+  p1 = False :: Bool+  p2 = False :: Bool+Solution #4:+  x  =    0 :: Integer+  y  =    0 :: Integer+  p1 = True :: Bool+  p2 = True :: Bool+Found 4 different solutions.++Without the call to 'partition' in the above example, 'allSat' would return all possible combinations of @x@ and @y@ subject to the constraints. (Since we have none here,+the call would try to enumerate the infinite set of all integer tuples!) But 'partition' allows us to restrict our attention to the examples that satisfy the partitioning+constraints. The first argument to 'partition' is simply a name, for diagnostic purposes. Note that the conditions given by 'partition' are /not/ imposed on the search+space at all: They're only used when we construct the search space. In the above example, we pick one example from each quadrant. Furthermore, while it is typical to pass+a boolean as a partitioning argument, it is not required: Any expression is OK, whose value creates the equivalence class:++>>> :{+allSat $ do+   x <- sInteger "x"+   partition "p" $ x `sMod` 3+:}+Solution #1:+  x = 2 :: Integer+  p = 2 :: Integer+Solution #2:+  x = 1 :: Integer+  p = 1 :: Integer+Solution #3:+  x = 0 :: Integer+  p = 0 :: Integer+Found 3 different solutions.++In the above, we get three examples, as the expression @x mod 3@ can take only three different values.+-}+ {- $constrainIntro A constraint is a means for restricting the input domain of a formula. Here's a simple example:@@ -1231,15 +1297,15 @@ Q.E.D. >>> prove $ roundTrip @Int32 Falsifiable. Counter-example:-  s0 = RoundNearestTiesToAway :: RoundingMode-  s1 =             -740395022 :: Int32+  s0 = RoundTowardNegative :: RoundingMode+  s1 =          -536873931 :: Int32  Note how we get a failure on `Int32`. The counter-example value is not representable exactly as a single precision float: ->>> toRational (-740395022 :: Float)-(-740395008) % 1+>>> toRational (-536873931 :: Float)+(-536873920) % 1 -Note how the numerator is different, it is off by 14. This is hardly surprising, since floats become sparser as+Note how the numerator is different, it is off by 11. This is hardly surprising, since floats become sparser as the magnitude increases to be able to cover all the integer values representable.  >>> :{@@ -1261,16 +1327,16 @@ Q.E.D. >>> prove $ roundTrip @Int64 Falsifiable. Counter-example:-  s0 = RoundTowardPositive :: RoundingMode-  s1 = 1152921504606846896 :: Int64+  s0 = RoundNearestTiesToEven :: RoundingMode+  s1 =   -9223372036854775538 :: 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 (fromIntegral (1152921504606846896 :: Int64) :: Double)-1152921504606846848 % 1+>>> toRational (fromIntegral (-9223372036854775538 :: Int64) :: Double)+(-9223372036854775808) % 1 -In this case the numerator is off by 48.+In this case the numerator is off by 270. -}  -- | An implementation of rotate-left, using a barrel shifter like design. Only works when both@@ -1630,7 +1696,7 @@                        when (op `notElem` curSpecialRels) $ do                            registerKind st ka-                          newUninterpreted st (nm, Nothing) (SBVType [ka, ka, KBool]) UINone+                          newUninterpreted st (nm, Nothing) (SBVType [ka, ka, KBool]) (UINone True)                            -- Add to the end so if we get incremental ones the order doesn't change for old ones!                           modifyIORef' (rProgInfo st) (\u -> u{progSpecialRels = curSpecialRels ++ [iop]})
Data/SBV/Client.hs view
@@ -58,6 +58,7 @@ defaultSolverConfig CVC5      = cvc5 defaultSolverConfig DReal     = dReal defaultSolverConfig MathSAT   = mathSAT+defaultSolverConfig OpenSMT   = openSMT defaultSolverConfig Yices     = yices defaultSolverConfig Z3        = z3
Data/SBV/Client/BaseIO.hs view
@@ -15,6 +15,7 @@ {-# LANGUAGE DefaultSignatures    #-} {-# LANGUAGE FlexibleContexts     #-} {-# LANGUAGE FlexibleInstances    #-}+{-# LANGUAGE NamedFieldPuns       #-} {-# LANGUAGE TypeFamilies         #-} {-# LANGUAGE TypeOperators        #-} {-# LANGUAGE UndecidableInstances #-}@@ -28,12 +29,12 @@                                 SFPHalf, SFPBFloat, SFPSingle, SFPDouble, SFPQuad, SFloatingPoint,                                 SInt8, SInt16, SInt32, SInt64, SInteger, SList,                                 SReal, SString, SV, SWord8, SWord16, SWord32,-                                SWord64, SEither, SRational, SMaybe, SSet)+                                SWord64, SEither, SRational, SMaybe, SSet, constrain, (.==)) import Data.SBV.Core.Sized     (SInt, SWord, IntN, WordN) import Data.SBV.Core.Kind      (BVIsNonZero, ValidFloat) import Data.SBV.Core.Model     (Metric(..), SymTuple)-import Data.SBV.Core.Symbolic  (Objective, OptimizeStyle, Result, VarContext,-                                Symbolic, SBVRunMode, SMTConfig, SVal)+import Data.SBV.Core.Symbolic  (Objective, OptimizeStyle, Result, VarContext, Symbolic, SBVRunMode, SMTConfig,+                                SVal, symbolicEnv, rPartitionVars, State(..)) import Data.SBV.Control.Types  (SMTOption) import Data.SBV.Provers.Prover (Provable, Satisfiable, SExecutable, ThmResult) import Data.SBV.SMT.SMT        (AllSatResult, SafeResult, SatResult,@@ -45,12 +46,16 @@ import Data.Int import Data.Word +import Data.IORef(readIORef, writeIORef)+ import qualified Data.SBV.Core.Data      as Trans import qualified Data.SBV.Core.Sized     as Trans import qualified Data.SBV.Core.Model     as Trans import qualified Data.SBV.Core.Symbolic  as Trans import qualified Data.SBV.Provers.Prover as Trans +import Control.Monad.Trans (liftIO)+ -- | Prove a predicate, using the default solver. -- -- NB. For a version which generalizes over the underlying monad, see 'Data.SBV.Trans.prove'@@ -220,6 +225,24 @@ -- NB. For a version which generalizes over the underlying monad, see 'Data.SBV.Trans.output' output :: Outputtable a => a -> Symbolic a output = Trans.output++-- | Create a partitioning constraint, for all-sat calls.+partition :: SymVal a => String -> SBV a -> Symbolic ()+partition nm term = do+   State{rPartitionVars} <- symbolicEnv++   -- Generate a unique variable with the prefix nm if necessary and+   -- add it to partitions+   fresh <- liftIO $ do olds <- readIORef rPartitionVars+                        let new = case filter (`notElem` olds) (nm : [nm ++ "_" ++ show i | i <- [(1 :: Int) ..]]) of+                                    h:_ -> h+                                    []  -> error $ "Impossible: Can't get a fresh variable from infinite list in partition." ++ show (nm, term)+                        writeIORef rPartitionVars (olds ++ [new])+                        pure new++   -- declare and constrain+   v <- free fresh+   constrain $ v .== term  -- | Create a free variable, universal in a proof, existential in sat --
Data/SBV/Compilers/C.hs view
@@ -97,7 +97,7 @@  instance CgTarget SBVToC where   targetName _ = "C"-  translate _  = cgen+  translate  _ = cgen  -- Unexpected input, or things we will probably never support die :: String -> a@@ -187,7 +187,9 @@ pprCWord cnst v = (if cnst then text "const" else empty) <+> text (showCType v)  -- | Almost a "show", but map "SWord1" to "SBool"--- which is used for extracting one-bit words.+-- which is used for extracting one-bit words. This is OK since C's bool type+-- handles arithmetic fine, and maps nicely to our `SWord 1`. (Same isn't true for `SInt 1`, which+-- doesn't have an easy counter-part on the C side. showCType :: HasKind a => a -> String showCType i = case kindOf i of                 KBounded False 1 -> "SBool"@@ -262,7 +264,6 @@ showSizedConst _   i t@(True,  32) = text $ chex False True t i showSizedConst _   i t@(False, 64) = text $ chex False True t i showSizedConst _   i t@(True,  64) = text $ chex False True t i-showSizedConst _   i   (True,  1)  = die $ "Signed 1-bit value " ++ show i showSizedConst _   i   (s, sz)     = die $ "Constant " ++ show i ++ " at type " ++ (if s then "SInt" else "SWord") ++ show sz  -- | Generate a makefile. The first argument is True if we have a driver.@@ -452,22 +453,24 @@   = error $ "SBV->C: Unbounded integers are not supported by the C compiler."           ++ "\nUse 'cgIntegerSize' to specify a fixed size for SInteger representation."   | KString `Set.member` kindInfo-  = error "SBV->C: Strings are currently not supported by the C compiler. Please get in touch if you'd like support for this feature!"+  = notyet "Strings"   | KChar `Set.member` kindInfo-  = error "SBV->C: Characters are currently not supported by the C compiler. Please get in touch if you'd like support for this feature!"+  = notyet "Characters"   | any isSet kindInfo-  = error "SBV->C: Sets (SSet) are currently not supported by the C compiler. Please get in touch if you'd like support for this feature!"+  = notyet "Sets (SSet)"   | any isList kindInfo-  = error "SBV->C: Lists (SList) are currently not supported by the C compiler. Please get in touch if you'd like support for this feature!"+  = notyet "Lists (SList)"   | any isTuple kindInfo-  = error "SBV->C: Tuples (STupleN) are currently not supported by the C compiler. Please get in touch if you'd like support for this feature!"+  = notyet "Tuples (STupleN)"   | any isMaybe kindInfo-  = error "SBV->C: Optional (SMaybe) values are currently not supported by the C compiler. Please get in touch if you'd like support for this feature!"+  = notyet "Optional (SMaybe) values"   | any isEither kindInfo-  = error "SBV->C: Either (SEither) values are currently not supported by the C compiler. Please get in touch if you'd like support for this feature!"+  = notyet "Either (SEither) values"   | isNothing (cgReal cfg) && KReal `Set.member` kindInfo   = error $ "SBV->C: SReal values are not supported by the C compiler."           ++ "\nUse 'cgSRealType' to specify a custom type for SReal representation."+  | not (null unsupportedBVs)+  = error $ "SBV->C: Unsupported bit-vector type(s): " ++ intercalate ", " (map show unsupportedBVs)   | not (null usorts)   = error $ "SBV->C: Cannot compile functions with uninterpreted sorts: " ++ intercalate ", " usorts   | hasQuants pinfo@@ -482,7 +485,9 @@   = tbd "User specified arrays"   | True   = ([pre, header, post], flagsNeeded)- where asserts | cgIgnoreAsserts cfg = []+ where notyet m = error $ "SBV->C: " ++ m ++ " are currently not supported by the C compiler. Please get in touch if you'd like support for this feature!"++       asserts | cgIgnoreAsserts cfg = []                | True                = origAsserts         usorts = [s | KUserSort s _ <- Set.toList kindInfo, s /= "RoundingMode"] -- No support for any sorts other than RoundingMode!@@ -492,6 +497,10 @@         header = text "#include" <+> doubleQuotes (nm P.<> text ".h") +       unsupportedBVs = [k | k@(KBounded sg sz) <- Set.toList kindInfo, (not . supported) (sg, sz)]+         where supported (False, sz) = sz `elem` [1, 8, 16, 32, 64]+               supported (True,  sz) = sz `elem` [   8, 16, 32, 64]+        post   = text ""              $$ vcat (map codeSeg cgs)              $$ extDecls@@ -586,8 +595,8 @@          where static   = if location == -1 then text "static" else empty                location = maximum (-1 : map getNodeId elts) -       getNodeId s@(SV _ (NodeId (_, n))) | isConst s = -1-                                          | True      = n+       getNodeId s@(SV _ (NodeId (_, _, n))) | isConst s = -1+                                             | True      = n         genAsgn :: (SV, SBVExpr) -> (Int, Doc)        genAsgn (sv, n) = (getNodeId sv, ppExpr cfg consts n (declSV typeWidth sv) (declSVNoConst typeWidth sv) P.<> semi)@@ -747,6 +756,9 @@                                     _                         -> def         getShiftAmnt def _       = def +        hd _ (h:_) = h+        hd w []    = error $ "Data.SBV.C.ppExpr: Impossible happened: " ++ w ++ ", received empty list!"+         p :: Op -> [Doc] -> Doc         p (ArrRead _)       _  = tbd "User specified arrays (ArrRead)"         p (ArrEq _ _)       _  = tbd "User specified arrays (ArrEq)"@@ -757,13 +769,13 @@         p (KindCast _ to)   [a] = parens (text (show to)) <+> a         p (Uninterpreted s) [] = text "/* Uninterpreted constant */" <+> text s         p (Uninterpreted s) as = text "/* Uninterpreted function */" <+> text s P.<> parens (fsep (punctuate comma as))-        p (Extract i j) [a]    = extract i j (head opArgs) a+        p (Extract i j) [a]    = extract i j (hd "Extract" opArgs) a         p Join [a, b]          = join (let (s1 : s2 : _) = opArgs in (s1, s2, a, b))-        p (Rol i) [a]          = rotate True  i a (head opArgs)-        p (Ror i) [a]          = rotate False i a (head opArgs)+        p (Rol i) [a]          = rotate True  i a (hd "Rol" opArgs)+        p (Ror i) [a]          = rotate False i a (hd "Ror" opArgs)         p Shl     [a, i]       = shift  True  (getShiftAmnt i opArgs) a -- The order of i/a being reversed here is         p Shr     [a, i]       = shift  False (getShiftAmnt i opArgs) a -- intentional and historical (from the days when Shl/Shr had a constant parameter.)-        p Not [a]              = case kindOf (head opArgs) of+        p Not [a]              = case kindOf (hd "Not" opArgs) of                                    -- be careful about booleans, bitwise complement is not correct for them!                                    KBool -> text "!" P.<> a                                    _     -> text "~" P.<> a@@ -809,10 +821,10 @@         -- Div/Rem should be careful on 0, in the SBV world x `div` 0 is 0, x `rem` 0 is x         -- NB: Quot is supposed to truncate toward 0; Not clear to me if C guarantees this behavior.         -- Brief googling suggests C99 does indeed truncate toward 0, but other C compilers might differ.-        p Quot [a, b] = let k = kindOf (head opArgs)+        p Quot [a, b] = let k = kindOf (hd "Quot" opArgs)                             z = mkConst cfg $ mkConstCV k (0::Integer)                         in protectDiv0 k "/" z a b-        p Rem  [a, b] = protectDiv0 (kindOf (head opArgs)) "%" a a b+        p Rem  [a, b] = protectDiv0 (kindOf (hd "Rem" opArgs)) "%" a a b         p UNeg [a]    = parens (text "-" <+> a)         p Abs  [a]    = let f KFloat             = text "fabsf" P.<> parens a                             f KDouble            = text "fabs"  P.<> parens a@@ -828,15 +840,15 @@                                                      Just CgDouble     -> f KDouble                                                      Just CgLongDouble -> text "fabsl" P.<> parens a                             f _                  = text "abs" P.<> parens a-                        in f (kindOf (head opArgs))+                        in f (kindOf (hd "Abs" opArgs))         -- for And/Or, translate to boolean versions if on boolean kind-        p And [a, b] | kindOf (head opArgs) == KBool = a <+> text "&&" <+> b-        p Or  [a, b] | kindOf (head opArgs) == KBool = a <+> text "||" <+> b+        p And [a, b] | kindOf (hd "And" opArgs) == KBool = a <+> text "&&" <+> b+        p Or  [a, b] | kindOf (hd "Or"  opArgs) == KBool = a <+> text "||" <+> b         p o [a, b]           | Just co <- lookup o cBinOps           = a <+> text co <+> b -        p Implies [a, b] | kindOf (head opArgs) == KBool = parens (text "!" P.<> a <+> text "||" <+> b)+        p Implies [a, b] | kindOf (hd "Implies" opArgs) == KBool = parens (text "!" P.<> a <+> text "||" <+> b)          p NotEqual xs = mkDistinct xs         p o args = die $ "Received operator " ++ show o ++ " applied to " ++ show args@@ -951,7 +963,9 @@   where bundles     = map snd cfgBundles         kinds       = [k | CgPgmBundle k _ <- bundles]         nubKinds    = nub kinds-        bundleKind  = head nubKinds+        bundleKind  = case nubKinds of+                        bk:_ -> bk+                        []   -> error "Data.SBV.C: Impossible happened: mergeLibs: kinds ended up being empty!"         files       = concat [fs | CgPgmBundle _ fs <- bundles]         sigs        = concat [ss | (_, (CgHeader ss, _)) <- files]         anyMake     = not (null [() | (_, (CgMakefile{}, _)) <- files])
Data/SBV/Control/BaseIO.hs view
@@ -26,6 +26,8 @@ import qualified Data.SBV.Control.Query as Trans import qualified Data.SBV.Control.Utils as Trans +import Data.SBV.Utils.SExpr (SExpr)+ -- Data.SBV.Control.Query  -- | Ask solver for info.@@ -59,7 +61,7 @@ -- | Get the uninterpreted constants/functions recorded during a run. -- -- NB. For a version which generalizes over the underlying monad, see 'Data.SBV.Trans.Control.getUIs'-getUIs :: Query [(String, (Maybe [String], SBVType))]+getUIs :: Query [(String, (Bool, Maybe [String], SBVType))] getUIs = Trans.getUIs  -- | Issue check-sat and get an SMT Result out.@@ -468,8 +470,10 @@  -- | Get the value of an uninterpreted function, as a list of domain, value pairs. -- The final value is the "else" clause, i.e., what the function maps values outside--- of the domain of the first list.-getFunction :: (SymVal a, SymVal r, Trans.SMTFunction fun a r) => fun -> Query (Either String ([(a, r)], r))+-- of the domain of the first list. If the result is not a value-association, then we get a string+-- representation and the triple of whether it's curried, the argument list given by the user, and the s-expression as parsed+-- by SBV from the SMT solver.+getFunction :: (SymVal a, SymVal r, Trans.SMTFunction fun a r) => fun -> Query (Either (String, (Bool, Maybe [String], SExpr)) ([(a, r)], r)) getFunction = Trans.getFunction  -- | Get the value of a term. If the kind is Real and solver supports decimal approximations,@@ -480,13 +484,13 @@ getValueCV = Trans.getValueCV  -- | Get the value of an uninterpreted value-getUICVal :: Maybe Int -> (String, (Maybe [String], SBVType)) -> Query CV+getUICVal :: Maybe Int -> (String, (Bool, Maybe [String], SBVType)) -> Query CV getUICVal = Trans.getUICVal  -- | Get the value of an uninterpreted function as an association list -- -- NB. For a version which generalizes over the underlying monad, see 'Data.SBV.Trans.Control.getUIFunCVAssoc'-getUIFunCVAssoc :: Maybe Int -> (String, (Maybe [String], SBVType)) -> Query (Either String ([([CV], CV)], CV))+getUIFunCVAssoc :: Maybe Int -> (String, (Bool, Maybe [String], SBVType)) -> Query (Either String ([([CV], CV)], CV)) getUIFunCVAssoc = Trans.getUIFunCVAssoc  -- | Check for satisfiability.
Data/SBV/Control/Query.hs view
@@ -332,8 +332,8 @@               assocs   = S.fromList (sortOn fst obsvs) <> fmap removeSV (prepare inputAssocs)            -- collect UIs, and UI functions if requested-          let uiFuns = [ui | ui@(nm, (_, SBVType as)) <- uis, length as >  1, allSatTrackUFs cfg, not (mustIgnoreVar cfg nm)] -- functions have at least two things in their type!-              uiRegs = [ui | ui@(nm, (_, SBVType as)) <- uis, length as == 1,                     not (mustIgnoreVar cfg nm)]+          let uiFuns = [ui | ui@(nm, (_, _, SBVType as)) <- uis, length as >  1, allSatTrackUFs cfg, not (mustIgnoreVar cfg nm)] -- functions have at least two things in their type!+              uiRegs = [ui | ui@(nm, (_, _, SBVType as)) <- uis, length as == 1,                     not (mustIgnoreVar cfg nm)]            -- If there are uninterpreted functions, arrange so that z3's pretty-printer flattens things out           -- as cex's tend to get larger@@ -352,9 +352,9 @@                          then Just <$> mapM get allModelInputs                          else return Nothing -          uiFunVals <- mapM (\ui@(nm, (_, t)) -> (\a -> (nm, (t, a))) <$> getUIFunCVAssoc mbi ui) uiFuns+          uiFunVals <- mapM (\ui@(nm, (c, _, t)) -> (\a -> (nm, (c, t, a))) <$> getUIFunCVAssoc mbi ui) uiFuns -          uiVals    <- mapM (\ui@(nm, (_, _)) -> (nm,) <$> getUICVal mbi ui) uiRegs+          uiVals    <- mapM (\ui@(nm, (_, _, _)) -> (nm,) <$> getUICVal mbi ui) uiRegs            return SMTModel { modelObjectives = []                           , modelBindings   = toList <$> bindings
Data/SBV/Control/Utils.hs view
@@ -38,7 +38,7 @@      , timeout, queryDebug, retrieveResponse, recoverKindedValue, runProofOn, executeQuery      ) where -import Data.List  (sortBy, sortOn, elemIndex, partition, groupBy, tails, intercalate, nub, sort, isPrefixOf)+import Data.List  (sortBy, sortOn, elemIndex, partition, groupBy, tails, intercalate, nub, sort, isPrefixOf, isSuffixOf)  import Data.Char      (isPunctuation, isSpace, isDigit) import Data.Function  (on)@@ -372,7 +372,7 @@ -- | A class which allows for sexpr-conversion to functions class (HasKind r, SatModel r) => SMTFunction fun a r | fun -> a r where   sexprToArg     :: fun -> [SExpr] -> Maybe a-  smtFunName     :: (MonadIO m, SolverContext m, MonadSymbolic m) => fun -> m (String, Maybe [String])+  smtFunName     :: (MonadIO m, SolverContext m, MonadSymbolic m) => fun -> m ((String, Maybe [String]), Bool)   smtFunSaturate :: fun -> SBV r   smtFunType     :: fun -> SBVType   smtFunDefault  :: fun -> Maybe r@@ -396,8 +396,8 @@                     -- introduced it as an uninterperted name!                     newUIMap <- liftIO $ readIORef rUIMap                     case nm `Map.lookup` newUIMap of-                      Nothing          -> cantFind newUIMap-                      Just (mbArgs, _) -> pure (nm, mbArgs)+                      Nothing                     -> cantFind newUIMap+                      Just (isCurried, mbArgs, _) -> pure ((nm, mbArgs), isCurried)     where cantFind uiMap = error $ unlines $    [ ""                                                 , "*** Data.SBV.getFunction: Must be called on an uninterpreted function!"                                                 , "***"@@ -427,7 +427,7 @@                             (sv, SBVApp (Uninterpreted nm) _) | r == sv -> return nm                             _                                           -> cantFind uiMap -  sexprToFun f (s, e) = do nm <- fst <$> smtFunName f+  sexprToFun f (s, e) = do nm    <- fst . fst <$> smtFunName f                            mbRes <- case parseSExprFunction e of                                       Just (Left nm') -> case (nm == nm', smtFunDefault f) of                                                            (True, Just v)  -> return $ Just ([], v)@@ -451,9 +451,9 @@ -- function itself will register it automatically. But there are cases where doing this explicitly can -- come in handy. registerUISMTFunction :: (MonadIO m, SolverContext m, MonadSymbolic m) => SMTFunction fun a r => fun -> m ()-registerUISMTFunction f = do st   <- contextState-                             nmas <- smtFunName f-                             io $ newUninterpreted st nmas (smtFunType f) UINone+registerUISMTFunction f = do st                <- contextState+                             (nmas, isCurried) <- smtFunName f+                             io $ newUninterpreted st nmas (smtFunType f) (UINone isCurried)  -- | Pointwise function value extraction. If we get unlucky and can't parse z3's output (happens -- when we have all booleans and z3 decides to spit out an expression), just brute force our@@ -660,12 +660,159 @@                        (mkSaturatingArg (kindOf (Proxy @g)))                        (mkSaturatingArg (kindOf (Proxy @h))) +-- | Curried functions of arity 2+instance ( SymVal a,  HasKind a+         , SymVal b,  HasKind b+         , SatModel r, HasKind r+         ) => SMTFunction ((SBV a, SBV b) -> SBV r) (a, b) r+         where+  sexprToArg _ [a0, a1] = (,) <$> sexprToVal a0 <*> sexprToVal a1+  sexprToArg _ _        = Nothing++  smtFunType _ = SBVType [kindOf (Proxy @a), kindOf (Proxy @b), kindOf (Proxy @r)]++  smtFunSaturate f = f ( mkSaturatingArg (kindOf (Proxy @a))+                       , mkSaturatingArg (kindOf (Proxy @b))+                       )++-- | Curried functions of arity 3+instance ( SymVal a,  HasKind a+         , SymVal b,  HasKind b+         , SymVal c,  HasKind c+         , SatModel r, HasKind r+         ) => SMTFunction ((SBV a, SBV b, SBV c) -> SBV r) (a, b, c) r+         where+  sexprToArg _ [a0, a1, a2] = (,,) <$> sexprToVal a0 <*> sexprToVal a1 <*> sexprToVal a2+  sexprToArg _ _            = Nothing++  smtFunType _ = SBVType [kindOf (Proxy @a), kindOf (Proxy @b), kindOf (Proxy @c), kindOf (Proxy @r)]++  smtFunSaturate f = f ( mkSaturatingArg (kindOf (Proxy @a))+                       , mkSaturatingArg (kindOf (Proxy @b))+                       , mkSaturatingArg (kindOf (Proxy @c))+                       )++-- | Curried functions of arity 4+instance ( SymVal a,  HasKind a+         , SymVal b,  HasKind b+         , SymVal c,  HasKind c+         , SymVal d,  HasKind d+         , SatModel r, HasKind r+         ) => SMTFunction ((SBV a, SBV b, SBV c, SBV d) -> SBV r) (a, b, c, d) r+         where+  sexprToArg _ [a0, a1, a2, a3] = (,,,) <$> sexprToVal a0 <*> sexprToVal a1 <*> sexprToVal a2 <*> sexprToVal a3+  sexprToArg _ _                = Nothing++  smtFunType _ = SBVType [kindOf (Proxy @a), kindOf (Proxy @b), kindOf (Proxy @c), kindOf (Proxy @d), kindOf (Proxy @r)]++  smtFunSaturate f = f ( mkSaturatingArg (kindOf (Proxy @a))+                       , mkSaturatingArg (kindOf (Proxy @b))+                       , mkSaturatingArg (kindOf (Proxy @c))+                       , mkSaturatingArg (kindOf (Proxy @d))+                       )++-- | Curried functions of arity 5+instance ( SymVal a,  HasKind a+         , SymVal b,  HasKind b+         , SymVal c,  HasKind c+         , SymVal d,  HasKind d+         , SymVal e,  HasKind e+         , SatModel r, HasKind r+         ) => SMTFunction ((SBV a, SBV b, SBV c, SBV d, SBV e) -> SBV r) (a, b, c, d, e) r+         where+  sexprToArg _ [a0, a1, a2, a3, a4] = (,,,,) <$> sexprToVal a0 <*> sexprToVal a1 <*> sexprToVal a2 <*> sexprToVal a3 <*> sexprToVal a4+  sexprToArg _ _                    = Nothing++  smtFunType _ = SBVType [kindOf (Proxy @a), kindOf (Proxy @b), kindOf (Proxy @c), kindOf (Proxy @d), kindOf (Proxy @e), kindOf (Proxy @r)]++  smtFunSaturate f = f ( mkSaturatingArg (kindOf (Proxy @a))+                       , mkSaturatingArg (kindOf (Proxy @b))+                       , mkSaturatingArg (kindOf (Proxy @c))+                       , mkSaturatingArg (kindOf (Proxy @d))+                       , mkSaturatingArg (kindOf (Proxy @e))+                       )++-- | Curried functions of arity 6+instance ( SymVal a,  HasKind a+         , SymVal b,  HasKind b+         , SymVal c,  HasKind c+         , SymVal d,  HasKind d+         , SymVal e,  HasKind e+         , SymVal f,  HasKind f+         , SatModel r, HasKind r+         ) => SMTFunction ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> SBV r) (a, b, c, d, e, f) r+         where+  sexprToArg _ [a0, a1, a2, a3, a4, a5] = (,,,,,) <$> sexprToVal a0 <*> sexprToVal a1 <*> sexprToVal a2 <*> sexprToVal a3 <*> sexprToVal a4 <*> sexprToVal a5+  sexprToArg _ _                        = Nothing++  smtFunType _ = SBVType [kindOf (Proxy @a), kindOf (Proxy @b), kindOf (Proxy @c), kindOf (Proxy @d), kindOf (Proxy @e), kindOf (Proxy @f), kindOf (Proxy @r)]++  smtFunSaturate f = f ( mkSaturatingArg (kindOf (Proxy @a))+                       , mkSaturatingArg (kindOf (Proxy @b))+                       , mkSaturatingArg (kindOf (Proxy @c))+                       , mkSaturatingArg (kindOf (Proxy @d))+                       , mkSaturatingArg (kindOf (Proxy @e))+                       , mkSaturatingArg (kindOf (Proxy @f))+                       )++-- | Curried functions of arity 7+instance ( SymVal a,  HasKind a+         , SymVal b,  HasKind b+         , SymVal c,  HasKind c+         , SymVal d,  HasKind d+         , SymVal e,  HasKind e+         , SymVal f,  HasKind f+         , SymVal g,  HasKind g+         , SatModel r, HasKind r+         ) => SMTFunction ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> SBV r) (a, b, c, d, e, f, g) r+         where+  sexprToArg _ [a0, a1, a2, a3, a4, a5, a6] = (,,,,,,) <$> sexprToVal a0 <*> sexprToVal a1 <*> sexprToVal a2 <*> sexprToVal a3 <*> sexprToVal a4 <*> sexprToVal a5 <*> sexprToVal a6+  sexprToArg _ _                            = Nothing++  smtFunType _ = SBVType [kindOf (Proxy @a), kindOf (Proxy @b), kindOf (Proxy @c), kindOf (Proxy @d), kindOf (Proxy @e), kindOf (Proxy @f), kindOf (Proxy @g), kindOf (Proxy @r)]++  smtFunSaturate f = f ( mkSaturatingArg (kindOf (Proxy @a))+                       , mkSaturatingArg (kindOf (Proxy @b))+                       , mkSaturatingArg (kindOf (Proxy @c))+                       , mkSaturatingArg (kindOf (Proxy @d))+                       , mkSaturatingArg (kindOf (Proxy @e))+                       , mkSaturatingArg (kindOf (Proxy @f))+                       , mkSaturatingArg (kindOf (Proxy @g))+                       )++-- | Curried functions of arity 8+instance ( SymVal a,  HasKind a+         , SymVal b,  HasKind b+         , SymVal c,  HasKind c+         , SymVal d,  HasKind d+         , SymVal e,  HasKind e+         , SymVal f,  HasKind f+         , SymVal g,  HasKind g+         , SymVal h,  HasKind h+         , SatModel r, HasKind r+         ) => SMTFunction ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h) -> SBV r) (a, b, c, d, e, f, g, h) r+         where+  sexprToArg _ [a0, a1, a2, a3, a4, a5, a6, a7] = (,,,,,,,) <$> sexprToVal a0 <*> sexprToVal a1 <*> sexprToVal a2 <*> sexprToVal a3 <*> sexprToVal a4 <*> sexprToVal a5 <*> sexprToVal a6 <*> sexprToVal a7+  sexprToArg _ _                                = Nothing++  smtFunType _ = SBVType [kindOf (Proxy @a), kindOf (Proxy @b), kindOf (Proxy @c), kindOf (Proxy @d), kindOf (Proxy @e), kindOf (Proxy @f), kindOf (Proxy @g), kindOf (Proxy @h), kindOf (Proxy @r)]++  smtFunSaturate f = f ( mkSaturatingArg (kindOf (Proxy @a))+                       , mkSaturatingArg (kindOf (Proxy @b))+                       , mkSaturatingArg (kindOf (Proxy @c))+                       , mkSaturatingArg (kindOf (Proxy @d))+                       , mkSaturatingArg (kindOf (Proxy @e))+                       , mkSaturatingArg (kindOf (Proxy @f))+                       , mkSaturatingArg (kindOf (Proxy @g))+                       , mkSaturatingArg (kindOf (Proxy @h))+                       )+ -- Turn "((F (lambda ((x!1 Int)) (+ 3 (* 2 x!1)))))" -- into something more palatable. -- If we can't do that, we simply return the input unchanged-trimFunctionResponse :: String -> String -> Maybe [String] -> String-trimFunctionResponse resp nm mbArgs-  | Just parsed <- makeHaskellFunction resp nm mbArgs+trimFunctionResponse :: String -> String -> Bool -> Maybe [String] -> String+trimFunctionResponse resp nm isCurried mbArgs+  | Just parsed <- makeHaskellFunction resp nm isCurried mbArgs   = parsed   | True   = def $ case trim resp of@@ -677,21 +824,21 @@  -- | Generalization of 'Data.SBV.Control.getFunction' getFunction :: (MonadIO m, MonadQuery m, SolverContext m, MonadSymbolic m, SymVal a, SymVal r, SMTFunction fun a r)-            => fun -> m (Either String ([(a, r)], r))-getFunction f = do (nm, args) <- smtFunName f+            => fun -> m (Either (String, (Bool, Maybe [String], SExpr))  ([(a, r)], r))+getFunction f = do ((nm, args), isCurried) <- smtFunName f                     let cmd = "(get-value (" ++ nm ++ "))"                        bad = unexpected "getFunction" cmd "a function value" Nothing                     r <- ask cmd -                   parse r bad $ \case EApp [EApp [ECon o, e]] | o == nm -> do mbAssocs <- sexprToFun f (trimFunctionResponse r nm args, e)+                   parse r bad $ \case EApp [EApp [ECon o, e]] | o == nm -> do mbAssocs <- sexprToFun f (trimFunctionResponse r nm isCurried args, e)                                                                                case mbAssocs of                                                                                  Right assocs -> return $ Right assocs                                                                                  Left  raw    -> do mbPVS <- pointWiseExtract nm (smtFunType f)                                                                                                     case mbPVS >>= convert of                                                                                                       Just x  -> return $ Right x-                                                                                                      Nothing -> return $ Left raw+                                                                                                      Nothing -> return $ Left (raw, (isCurried, args, e))                                        _                                 -> bad r Nothing     where convert    (vs, d) = (,) <$> mapM sexprPoint vs <*> sexprToVal d           sexprPoint (as, v) = (,) <$> sexprToArg f as    <*> sexprToVal v@@ -816,14 +963,14 @@   where getUIIndex (KUserSort  _ (Just xs)) i = i `elemIndex` xs         getUIIndex _                        _ = Nothing -        stringLike xs = length xs >= 2 && head xs == '"' && last xs == '"'+        stringLike xs = length xs >= 2 && "\"" `isPrefixOf` xs && "\"" `isSuffixOf` xs          -- Make sure strings are really strings         interpretString xs           | not (stringLike xs)           = error $ "Expected a string constant with quotes, received: <" ++ xs ++ ">"           | True-          = qfsToString $ tail (init xs)+          = qfsToString $ drop 1 (init xs)          interpretChar xs = case interpretString xs of                              [c] -> c@@ -1012,14 +1159,14 @@                            _                                   -> bad r Nothing  -- | Generalization of 'Data.SBV.Control.getUICVal'-getUICVal :: forall m. (MonadIO m, MonadQuery m) => Maybe Int -> (String, (Maybe [String], SBVType)) -> m CV-getUICVal mbi (nm, (_, t)) = case t of-                              SBVType [k] -> extractValue mbi nm k-                              _           -> error $ "SBV.getUICVal: Expected to be called on an uninterpeted value of a base type, received something else: " ++ show (nm, t)+getUICVal :: forall m. (MonadIO m, MonadQuery m) => Maybe Int -> (String, (Bool, Maybe [String], SBVType)) -> m CV+getUICVal mbi (nm, (_, _, t)) = case t of+                                 SBVType [k] -> extractValue mbi nm k+                                 _           -> error $ "SBV.getUICVal: Expected to be called on an uninterpeted value of a base type, received something else: " ++ show (nm, t)  -- | Generalization of 'Data.SBV.Control.getUIFunCVAssoc'-getUIFunCVAssoc :: forall m. (MonadIO m, MonadQuery m) => Maybe Int -> (String, (Maybe [String], SBVType)) -> m (Either String ([([CV], CV)], CV))-getUIFunCVAssoc mbi (nm, (mbArgs, typ)) = do+getUIFunCVAssoc :: forall m. (MonadIO m, MonadQuery m) => Maybe Int -> (String, (Bool, Maybe [String], SBVType)) -> m (Either String ([([CV], CV)], CV))+getUIFunCVAssoc mbi (nm, (isCurried, mbArgs, typ)) = do   let modelIndex = case mbi of                      Nothing -> ""                      Just i  -> " :model_index " ++ show i@@ -1043,7 +1190,7 @@       toRes = recoverKindedValue rt        -- if we fail to parse, we'll return this answer as the string-      fallBack = trimFunctionResponse r nm mbArgs+      fallBack = trimFunctionResponse r nm isCurried mbArgs        -- In case we end up in the pointwise scenario, boolify the result       -- as that's the only type we support here.@@ -1113,11 +1260,11 @@  -- | Get UIs, both constants and functions. This call returns both the before and after query ones. -- Generalization of 'Data.SBV.Control.getUIs'.-getUIs :: forall m. (MonadIO m, MonadQuery m) => m [(String, (Maybe [String], SBVType))]+getUIs :: forall m. (MonadIO m, MonadQuery m) => m [(String, (Bool, Maybe [String], SBVType))] getUIs = do State{rUIMap, rDefns, rIncState} <- queryState             -- NB. no need to worry about new-defines, because we don't allow definitions once query mode starts             defines <- do allDefs <- io $ readIORef rDefns-                          pure $ mapMaybe smtDefGivenName allDefs+                          pure $ mapMaybe (smtDefGivenName . fst) allDefs              prior <- io $ readIORef rUIMap             new   <- io $ readIORef rIncState >>= readIORef . rNewUIs@@ -1136,27 +1283,29 @@                                         , "*** Please use a solver that supports this feature."                                         ] -                     topState@State{rUsedKinds} <- queryState+                     topState@State{rUsedKinds, rPartitionVars, rProgInfo} <- queryState -                     ki   <- liftIO $ readIORef rUsedKinds+                     progInfo <- liftIO $ readIORef rProgInfo+                     ki       <- liftIO $ readIORef rUsedKinds                       allModelInputs    <- getTopLevelInputs                      allUninterpreteds <- getUIs+                     partitionVars     <- liftIO $ readIORef rPartitionVars                        -- Functions have at least two kinds in their type and all components must be "interpreted"-                     let allUiFuns = [u | allSatTrackUFs cfg                                           -- config says consider UIFs-                                        , u@(nm, (_, SBVType as)) <- allUninterpreteds, length as > 1  -- get the function ones-                                        , not (mustIgnoreVar cfg nm)                                    -- make sure they aren't explicitly ignored+                     let allUiFuns = [u | allSatTrackUFs cfg                                              -- config says consider UIFs+                                        , u@(nm, (_, _, SBVType as)) <- allUninterpreteds, length as > 1  -- get the function ones+                                        , not (mustIgnoreVar cfg nm)                                      -- make sure they aren't explicitly ignored                                      ] -                         allUiRegs = [u | u@(nm, (_, SBVType as)) <- allUninterpreteds, length as == 1 -- non-function ones-                                        , not (mustIgnoreVar cfg nm)                                   -- make sure they aren't explicitly ignored+                         allUiRegs = [u | u@(nm, (_, _, SBVType as)) <- allUninterpreteds, length as == 1 -- non-function ones+                                        , not (mustIgnoreVar cfg nm)                                      -- make sure they aren't explicitly ignored                                      ]                           -- We can only "allSat" if all component types themselves are interpreted. (Otherwise                          -- there is no way to reflect back the values to the solver.)                          collectAcceptable []                                sofar = return sofar-                         collectAcceptable ((nm, (_, t@(SBVType ats))):rest) sofar+                         collectAcceptable ((nm, (_, _, t@(SBVType ats))):rest) sofar                            | not (any hasUninterpretedSorts ats)                            = collectAcceptable rest (nm : sofar)                            | True@@ -1184,27 +1333,31 @@                                                        ]                       -- Drop the things that are not model vars or internal-                     let vars :: S.Seq (SVal, NamedSymVar)-                         vars = let mkSVal nm@(getSV -> sv) = (SVal (kindOf sv) (Right (cache (const (return sv)))), nm)--                                    ignored k = mustIgnoreVar cfg (getUserName' k)+                     let mkSVal nm@(getSV -> sv) = (SVal (kindOf sv) (Right (cache (const (return sv)))), nm)+                     let extractVars :: S.Seq (SVal, NamedSymVar)+                         extractVars = mkSVal <$> S.filter (not . mustIgnoreVar cfg . getUserName') allModelInputs -                                in mkSVal <$> S.filter (not . ignored) allModelInputs+                         vars :: S.Seq (SVal, NamedSymVar)+                         vars = case partitionVars of+                                  [] -> extractVars+                                  pv -> mkSVal <$> S.filter (\k -> getUserName' k `elem` pv) allModelInputs                       -- We can go fast using the disjoint model trick if things are simple enough:                      --     - No uninterpreted functions (uninterpreted values are OK)                      --     - No uninterpreted sorts+                     --     - No quantifiers                      --                      -- Why can't we support the above?                      --     - Uninterpreted functions: There is no (standard) way to define a function as a literal in SMTLib.                      --     Some solvers support lambda, but this isn't common/reliable yet.                      --     - Uninterpreted sort: There's no way to access the value the solver assigns to an uninterpreted sort.+                     --     - Quantifiers: Too complicated!                      --                      -- So, if these two things are present, we go the "slow" route, by repeatedly rejecting the                      -- previous model and asking for a new one. If they don't exist (which is the common case anyhow)                      -- we use an idea due to z3 folks <http://theory.stanford.edu/%7Enikolaj/programmingz3.html#sec-blocking-evaluations>                      -- which splits the search space into disjoint models and can produce results much more quickly.-                     let isSimple = null allUiFuns && null usorts+                     let isSimple = null allUiFuns && null usorts && not (hasQuants progInfo)                           start = AllSatResult { allSatMaxModelCountReached  = False                                               , allSatSolverReturnedUnknown = False@@ -1212,16 +1365,28 @@                                               , allSatResults               = []                                               } +                     -- partition-variables are only supported if simple+                     case partitionVars of+                       [] -> pure ()+                       xs -> unless isSimple $ error $ unlines [ ""+                                                               , "Data.SBV: Unsupported complex allSat call in the presence of partition-variables"+                                                               , ""+                                                               , "Partition variables are only supported when there are no uninterpreted"+                                                               , "functions or uninterpreted sorts."+                                                               , ""+                                                               , "Saw parition vars: " ++ unwords xs+                                                               ]+                      if isSimple-                        then do let mkVar :: (String, (Maybe [String], SBVType)) -> IO (SVal, NamedSymVar)-                                    mkVar (nm, (_, SBVType [k])) = do sv <- newExpr topState k (SBVApp (Uninterpreted nm) [])-                                                                      let sval = SVal k $ Right $ cache $ \_ -> pure sv-                                                                          nsv  = NamedSymVar sv (T.pack nm)-                                                                      pure (sval, nsv)+                        then do let mkVar :: (String, (Bool, Maybe [String], SBVType)) -> IO (SVal, NamedSymVar)+                                    mkVar (nm, (_, _, SBVType [k])) = do sv <- newExpr topState k (SBVApp (Uninterpreted nm) [])+                                                                         let sval = SVal k $ Right $ cache $ \_ -> pure sv+                                                                             nsv  = NamedSymVar sv (T.pack nm)+                                                                         pure (sval, nsv)                                     mkVar nmt = error $ "Data.SBV: Impossible happened; allSat.mkVar. Unexpected: " ++ show nmt                                 uiVars <- io $ S.fromList <$> mapM mkVar allUiRegs-                                fastAllSat                                        allModelInputs (uiVars S.>< vars) cfg start-                        else    loop       topState (allUiFuns, uiFuns) allUiRegs allModelInputs              vars  cfg start+                                fastAllSat                                        allModelInputs (uiVars S.>< extractVars) (uiVars S.>< vars) cfg start+                        else    loop       topState (allUiFuns, uiFuns) allUiRegs allModelInputs                                        vars  cfg start     where isFree (KUserSort _ Nothing) = True          isFree _                     = False@@ -1236,8 +1401,8 @@                              Nothing -> pure ()                              Just m  -> io $ putStrLn m -         fastAllSat :: S.Seq NamedSymVar -> S.Seq (SVal, NamedSymVar) -> SMTConfig -> AllSatResult -> m AllSatResult-         fastAllSat allInputs vars cfg start = do+         fastAllSat :: S.Seq NamedSymVar -> S.Seq (SVal, NamedSymVar) -> S.Seq (SVal, NamedSymVar) -> SMTConfig -> AllSatResult -> m AllSatResult+         fastAllSat allInputs extractVars vars cfg start = do                 result <- io $ newIORef (0, start, False, Nothing)                 go result vars                 (found, sofar, _, extra) <- io $ readIORef result@@ -1289,7 +1454,7 @@                                                    io $ modifyIORef' finalResult $ \(h, s, _, _) -> (h, s{allSatSolverReturnedDSat = True}, True, Just ("[" ++ m ++ "]"))                                        Sat    -> do assocs <- mapM (\(sval, NamedSymVar sv n) -> do !cv <- getValueCV Nothing sv-                                                                                                   return (sv, (n, (sval, cv)))) vars+                                                                                                   return (sv, (n, (sval, cv)))) extractVars                                                     bindings <- let grab i@(getSV -> sv) = case lookupInput fst sv assocs of                                                                                             Just (_, (_, (_, cv))) -> return (i, cv)@@ -1391,8 +1556,8 @@                           Sat    -> do assocs <- mapM (\(sval, NamedSymVar sv n) -> do !cv <- getValueCV Nothing sv                                                                                        return (sv, (n, (sval, cv)))) vars -                                       let getUIFun ui@(nm, (_, t)) = do cvs <- getUIFunCVAssoc Nothing ui-                                                                         return (nm, (t, cvs))+                                       let getUIFun ui@(nm, (isCurried, _, t)) = do cvs <- getUIFunCVAssoc Nothing ui+                                                                                    return (nm, (isCurried, t, cvs))                                        uiFunVals <- mapM getUIFun allUiFuns                                         uiRegVals <- mapM (\ui@(nm, _) -> (nm,) <$> getUICVal Nothing ui) allUiRegs@@ -1465,7 +1630,7 @@                                                      (rejects, defs) = unzip [mkNotEq ui | ui@(nm, _) <- uiFunVals, nm `elem` uiFunsToReject]                                                       -- Otherwise, we have things to refute, go for it if we have a good interpretation for it-                                                     mkNotEq (nm, (typ, Left def)) =+                                                     mkNotEq (nm, (_, typ, Left def)) =                                                         error $ unlines [                                                             ""                                                           , "*** allSat: Unsupported: Building a rejecting instance for:"@@ -1487,7 +1652,7 @@                                                           , "***"                                                           , "*** NB. If this is a use case you'd like SBV to support, please get in touch!"                                                           ]-                                                     mkNotEq (nm, (SBVType ts, Right vs)) = (reject, def ++ dif)+                                                     mkNotEq (nm, (_, SBVType ts, Right vs)) = (reject, def ++ dif)                                                        where nm' = nm ++ "_model" ++ show cnt                                                               reject = nm' ++ "_reject"
Data/SBV/Core/AlgReals.hs view
@@ -9,7 +9,8 @@ -- Algebraic reals in Haskell. ----------------------------------------------------------------------------- -{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE DeriveDataTypeable #-}+{-# LANGUAGE FlexibleInstances  #-}  {-# OPTIONS_GHC -Wall -Werror -fno-warn-orphans #-} @@ -41,10 +42,12 @@  import Text.Read(readMaybe) +import qualified Data.Generics as G+ -- | Is the endpoint included in the interval? data RealPoint a = OpenPoint   a -- ^ open: i.e., doesn't include the point                  | ClosedPoint a -- ^ closed: i.e., includes the point-                 deriving (Show, Eq, Ord)+                 deriving (Show, Eq, Ord, G.Data)  -- | Extract the point associated with the open-closed point realPoint :: RealPoint a -> a@@ -57,6 +60,7 @@ data AlgReal = AlgRational Bool Rational                             -- ^ bool says it's exact (i.e., SMT-solver did not return it with ? at the end.)              | AlgPolyRoot (Integer,  AlgRealPoly) (Maybe String)    -- ^ which root of this polynomial and an approximate decimal representation with given precision, if available              | AlgInterval (RealPoint Rational) (RealPoint Rational) -- ^ interval, with low and high bounds+             deriving G.Data  -- | Check whether a given argument is an exact rational isExactRational :: AlgReal -> Bool@@ -67,7 +71,7 @@ -- coefficient list. For instance, "5x^3 + 2x - 5" is -- represented as [(5, 3), (2, 1), (-5, 0)] newtype AlgRealPoly = AlgRealPoly [(Integer, Integer)]-                   deriving (Eq, Ord)+                   deriving (Eq, Ord, G.Data)  -- | Construct a poly-root real with a given approximate value (either as a decimal, or polynomial-root) mkPolyReal :: Either (Bool, String) (Integer, [(Integer, Integer)]) -> AlgReal@@ -98,7 +102,10 @@  instance Show AlgRealPoly where   show (AlgRealPoly xs) = chkEmpty (join (concat [term p | p@(_, x) <- xs, x /= 0])) ++ " = " ++ show c-     where c  = -1 * head ([k | (k, 0) <- xs] ++ [0])+     where c  = -1 * case [k | (k, 0) <- xs] of+                       h:_ -> h+                       _   -> 0+            term ( 0, _) = []            term ( 1, 1) = [ "x"]            term ( 1, p) = [ "x^" ++ show p]
Data/SBV/Core/Concrete.hs view
@@ -9,15 +9,14 @@ -- Operations on concrete values ----------------------------------------------------------------------------- +{-# LANGUAGE DeriveDataTypeable  #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TypeApplications    #-} {-# LANGUAGE Rank2Types          #-}  {-# OPTIONS_GHC -Wall -Werror #-} -module Data.SBV.Core.Concrete-  ( module Data.SBV.Core.Concrete-  ) where+module Data.SBV.Core.Concrete where  import Control.Monad (replicateM) @@ -25,7 +24,7 @@ import System.Random (randomIO, randomRIO)  import Data.Char (chr, isSpace)-import Data.List (isPrefixOf, intercalate)+import Data.List (intercalate)  import Data.SBV.Core.Kind import Data.SBV.Core.AlgReals@@ -38,9 +37,12 @@ import Data.Set (Set) import qualified Data.Set as Set +import qualified Data.Generics as G+ -- | A 'RCSet' is either a regular set or a set given by its complement from the corresponding universal set. data RCSet a = RegularSet    (Set a)              | ComplementSet (Set a)+             deriving G.Data  -- | Show instance. Regular sets are shown as usual. -- Complements are shown "U -" notation.@@ -85,6 +87,7 @@           | CTuple    ![CVal]              -- ^ Tuple           | CMaybe    !(Maybe CVal)        -- ^ Maybe           | CEither   !(Either CVal CVal)  -- ^ Disjoint union+          deriving G.Data  -- | Assign a rank to constant values, this is structural and helps with ordering cvRank :: CVal -> Int@@ -163,7 +166,7 @@ data CV = CV { _cvKind  :: !Kind              , cvVal    :: !CVal              }-        deriving (Eq, Ord)+             deriving (Eq, Ord, G.Data)  -- | A generalized CV allows for expressions involving infinite and epsilon values/intervals Used in optimization problems. data GeneralizedCV = ExtendedCV ExtCV@@ -214,9 +217,8 @@                                        | True       = v ++ " :: "  ++ showBaseKind (kindOf extCV)                   add :: String -> String -> String-                 add n v-                  | "-" `isPrefixOf` v = n ++ " - " ++ tail v-                  | True               = n ++ " + " ++ v+                 add n ('-':v) = n ++ " - " ++ v+                 add n v       = n ++ " + " ++ v                   mul :: String -> String -> String                  mul n v = n ++ " * " ++ v@@ -454,7 +456,7 @@               | True       = v               where needsParen = case dropWhile isSpace v of                                    []         -> False-                                   rest@(x:_) -> any isSpace rest && x `notElem` "{[("+                                   rest@(x:_) -> x == '-' || (any isSpace rest && x `notElem` "{[(")  -- | Create a constant word from an integral. mkConstCV :: Integral a => Kind -> a -> CV
Data/SBV/Core/Data.hs view
@@ -745,7 +745,7 @@            where ks   = (kindOf (Proxy @a), kindOf (Proxy @b))                  r st = do amap <- R.readIORef (rArrayMap st) -                           let k    = ArrayIndex $ IMap.size amap+                           let k    = ArrayIndex (IMap.size amap) (sbvContext st)                                iVal = literal initializer                             iSV <- sbvToSV st iVal@@ -908,7 +908,7 @@ instance (HasKind a, KnownSymbol nm, Skolemize r) => Skolemize (Exists nm a -> r) where   type SkolemsTo (Exists nm a -> r) = SkolemsTo r   skolem scope args f = skolem scope args (f (Exists skolemized))-    where skolemized = SBV $ svUninterpretedNamedArgs (kindOf (Proxy @a)) (scope ++ symbolVal (Proxy @nm)) UINone args+    where skolemized = SBV $ svUninterpretedNamedArgs (kindOf (Proxy @a)) (scope ++ symbolVal (Proxy @nm)) (UINone True) args  -- | Skolemize over a number of existential quantifiers instance (HasKind a, KnownNat n, KnownSymbol nm, Skolemize r) => Skolemize (ExistsN n nm a -> r) where@@ -917,7 +917,7 @@     where need   = intOfProxy (Proxy @n)           prefix = symbolVal (Proxy @nm)           fs     = [prefix ++ "_" ++ show i | i <- [1 .. need]]-          skolemized = [SBV $ svUninterpretedNamedArgs (kindOf (Proxy @a)) (scope ++ n) UINone args | n <- fs]+          skolemized = [SBV $ svUninterpretedNamedArgs (kindOf (Proxy @a)) (scope ++ n) (UINone True) args | n <- fs]  -- | Skolemize over a unique existential quantifier instance (  HasKind a@@ -930,7 +930,7 @@                                           -> Forall (AppendSymbol nm "_eu2") a                                           -> SBool   skolem scope args f = skolem scope args (rewriteExistsUnique f (Exists skolemized))-    where skolemized = SBV $ svUninterpretedNamedArgs (kindOf (Proxy @a)) (scope ++ symbolVal (Proxy @nm)) UINone args+    where skolemized = SBV $ svUninterpretedNamedArgs (kindOf (Proxy @a)) (scope ++ symbolVal (Proxy @nm)) (UINone True) args  -- | Class of things that we can logically negate class QNot a where
Data/SBV/Core/Model.hs view
@@ -90,8 +90,9 @@ import Data.SBV.Core.Operations import Data.SBV.Core.Kind import Data.SBV.Lambda+import Data.SBV.Utils.ExtractIO(ExtractIO) -import Data.SBV.Provers.Prover (defaultSMTCfg, SafeResult(..), prove)+import Data.SBV.Provers.Prover (defaultSMTCfg, SafeResult(..), defs2smt, prove) import Data.SBV.SMT.SMT        (ThmResult, showModel)  import Data.SBV.Utils.Lib     (isKString)@@ -845,7 +846,8 @@               | [SBV a, SBV b] <- xs, b `is` svBool True  = SBV $ svNot a               | [SBV a, SBV b] <- xs, a `is` svBool False = SBV b               | [SBV a, SBV b] <- xs, b `is` svBool False = SBV a-              | length xs > 2 && isBool (head xs)         = sFalse+              -- 3 booleans can't be distinct!+              | (x : _ : _ : _) <- xs, isBool x           = sFalse               | True                                      = SBV (SVal KBool (Right (cache r)))     where r st = do xsv <- mapM (sbvToSV st) xs                     newExpr st KBool (SBVApp NotEqual xsv)@@ -871,10 +873,10 @@    -- Custom version of distinctExcept that generates better code for base types   -- We essentially keep track of an array and count cardinalities as we walk along.-  distinctExcept []  _       = sTrue-  distinctExcept [_] _       = sTrue-  distinctExcept es  ignored-     | all isConc (es ++ ignored)+  distinctExcept []            _       = sTrue+  distinctExcept [_]           _       = sTrue+  distinctExcept es@(firstE:_) ignored+    | all isConc (es ++ ignored)     = distinct (filter ignoreConc es)     | True     = SBV (SVal KBool (Right (cache r)))@@ -882,7 +884,7 @@                            SBV (SVal KBool (Left cv)) -> cvToBool cv                            _                          -> error $ "distinctExcept: Impossible happened, concrete sElem failed: " ++ show (es, ignored, x) -          ek = case head es of  -- Head is safe here as we're guaranteed to have a non-empty es by pattern matching above. (Actually, there'll be at least two elements)+          ek = case firstE of                  SBV (SVal k _) -> k            r st = do let zero = 0 :: SInteger@@ -1086,6 +1088,9 @@     sPopCount           :: SBV a -> SWord8     -- | A combo of 'setBit' and 'clearBit', when the bit to be set is symbolic.     setBitTo            :: SBV a -> Int -> SBool -> SBV a+    -- | Variant of 'setBitTo' when the index is symbolic. If the index it out-of-bounds,+    -- then the result is underspecified.+    sSetBitTo           :: Integral a => SBV a -> SBV a -> SBool -> SBV a     -- | Full adder, returns carry-out from the addition. Only for unsigned quantities.     fullAdder           :: SBV a -> SBV a -> (SBool, SBV a)     -- | Full multiplier, returns both high and low-order bits. Only for unsigned quantities.@@ -1134,6 +1139,22 @@      setBitTo x i b = ite b (setBit x i) (clearBit x i) +    sSetBitTo x idx b+      | Just i <- unliteral idx, Just index <- safe i+      = setBitTo x index b+      | True+      = go x [0 .. sFiniteBitSize x - 1]+      where -- paranoia check: make sure index can fit in an int+            safe i = let asInteger   = toInteger i+                         asInt       = fromIntegral asInteger+                         backInteger = toInteger asInt+                     in if backInteger == asInteger+                        then Just asInt+                        else Nothing++            go v []     = v+            go v (i:is) = go (ite (idx .== literal (fromIntegral i)) (setBitTo v (fromIntegral i) b) v) is+     fullAdder a b       | isSigned a = error "fullAdder: only works on unsigned numbers"       | True       = (a .> s .|| b .> s, s)@@ -1332,6 +1353,7 @@      in product $ zipWith (\use n -> ite use n 1)                           blasted                           (iterate (\x -> x*x) b)+infixr 8 .^  instance (Ord a, SymVal a, Fractional a) => Fractional (SBV a) where   fromRational  = literal . fromRational@@ -2308,6 +2330,11 @@   -- the solver is free to instantiate to satisfy other constraints.   uninterpret :: String -> a +  -- | Uninterpret a value, with named arguments in case of functions. SBV will use these+  -- names when it shows the values for the arguments. If the given names are more than needed+  -- we ignore the excess. If not enough, we add from a stock set of variables.+  uninterpretWithArgs :: String -> [String] -> a+   -- | Uninterpret a value, only for the purposes of code-generation. For execution   -- and verification the value is used as is. For code-generation, the alternate   -- definition is used. This is useful when we want to take advantage of native@@ -2316,22 +2343,26 @@    -- | Most generalized form of uninterpretation, this function should not be needed   -- by end-user-code, but is rather useful for the library development.-  sbvDefineValue :: String -> UIKind a -> a+  sbvDefineValue :: String -> Maybe [String] -> UIKind a -> a    -- | A synonym for 'uninterpret'. Allows us to create variables without   -- having to call 'free' explicitly, i.e., without being in the symbolic monad.   sym :: String -> a -  {-# MINIMAL sbvDefineValue #-}+  -- | Render an uninterpeted value as an SMTLib definition+  sbv2smt :: ExtractIO m => a -> m String +  {-# MINIMAL sbvDefineValue, sbv2smt #-}+   -- defaults:-  uninterpret    nm        = sbvDefineValue nm   UIFree-  smtFunction    nm      v = sbvDefineValue nm $ UIFun   (v, \st fk -> namedLambda st nm fk v)-  cgUninterpret  nm code v = sbvDefineValue nm $ UICodeC (v, code)-  sym                      = uninterpret+  uninterpret         nm        = sbvDefineValue nm Nothing     (UIFree True)+  uninterpretWithArgs nm as     = sbvDefineValue nm (Just as)   (UIFree True)+  smtFunction         nm      v = sbvDefineValue nm Nothing   $ UIFun   (v, \st fk -> namedLambda st nm fk v)+  cgUninterpret       nm code v = sbvDefineValue nm Nothing   $ UICodeC (v, code)+  sym                           = uninterpret  -- | Kind of uninterpretation-data UIKind a = UIFree                                  -- ^ completely uninterpreted+data UIKind a = UIFree  Bool                            -- ^ completely uninterpreted. If Bool is true, then this is curried.               | UIFun   (a, State -> Kind -> IO SMTDef) -- ^ has code for SMTLib, with final type of kind (note this is the result                                                         -- , not the arguments), which can be generated by calling the function on the state.               | UICodeC (a, [String])                   -- ^ has code for code-generation, i.e., C@@ -2339,23 +2370,30 @@  -- Get the code associated with the UI, unless we've already did this once. (To support recursive defs.) retrieveUICode :: String -> State -> Kind -> UIKind a -> IO UICodeKind-retrieveUICode _  _  _  UIFree           = pure UINone+retrieveUICode _  _  _  (UIFree  c)       = pure $ UINone c retrieveUICode nm st fk (UIFun   (_, f)) = do userFuncs <- readIORef (rUserFuncs st)                                               if nm `Set.member` userFuncs-                                                 then pure UINone+                                                 then pure $ UINone True                                                  else do modifyState st rUserFuncs (Set.insert nm) (pure ())                                                          UISMT <$> f st fk retrieveUICode _  _  _  (UICodeC (_, c)) = pure $ UICgC c  -- Get the constant value associated with the UI retrieveConstCode :: UIKind a -> Maybe a-retrieveConstCode UIFree           = Nothing+retrieveConstCode UIFree{}         = Nothing retrieveConstCode (UIFun   (v, _)) = Just v retrieveConstCode (UICodeC (v, _)) = Just v  -- Plain constants instance HasKind a => SMTDefinable (SBV a) where-  sbvDefineValue nm uiKind+  sbv2smt a = do st <- mkNewState defaultSMTCfg (LambdaGen 0)+                 s <- lambdaStr st (kindOf a) a+                 pure $ intercalate "\n" [ "; Automatically generated by SBV. Do not modify!"+                                         , "; Type: " ++ smtType (kindOf a)+                                         , s+                                         ]++  sbvDefineValue nm mbArgs uiKind      | Just v <- retrieveConstCode uiKind      = v      | True@@ -2364,12 +2402,14 @@           result st = do isSMT <- inSMTMode st                          case (isSMT, uiKind) of                            (True, UICodeC (v, _)) -> sbvToSV st v-                           _                      -> do newUninterpreted st (nm, Nothing) (SBVType [ka]) =<< retrieveUICode nm st ka uiKind+                           _                      -> do newUninterpreted st (nm, mbArgs) (SBVType [ka]) =<< retrieveUICode nm st ka uiKind                                                         newExpr st ka $ SBVApp (Uninterpreted nm) []  -- Functions of one argument instance (SymVal b, HasKind a) => SMTDefinable (SBV b -> SBV a) where-  sbvDefineValue nm uiKind = f+  sbv2smt fn = defs2smt $ \b -> fn b .== fn b++  sbvDefineValue nm mbArgs uiKind = f     where f arg0            | Just v <- retrieveConstCode uiKind, isConcrete arg0            = v arg0@@ -2380,14 +2420,16 @@                  result st = do isSMT <- inSMTMode st                                 case (isSMT, uiKind) of                                   (True, UICodeC (v, _)) -> sbvToSV st (v arg0)-                                  _                      -> do newUninterpreted st (nm, Nothing) (SBVType [kb, ka]) =<< retrieveUICode nm st ka uiKind+                                  _                      -> do newUninterpreted st (nm, mbArgs) (SBVType [kb, ka]) =<< retrieveUICode nm st ka uiKind                                                                sw0 <- sbvToSV st arg0                                                                mapM_ forceSVArg [sw0]                                                                newExpr st ka $ SBVApp (Uninterpreted nm) [sw0]  -- Functions of two arguments instance (SymVal c, SymVal b, HasKind a) => SMTDefinable (SBV c -> SBV b -> SBV a) where-  sbvDefineValue nm uiKind = f+  sbv2smt fn = defs2smt $ \c b -> fn c b .== fn c b++  sbvDefineValue nm mbArgs uiKind = f     where f arg0 arg1            | Just v <- retrieveConstCode uiKind, isConcrete arg0, isConcrete arg1            = v arg0 arg1@@ -2399,7 +2441,7 @@                  result st = do isSMT <- inSMTMode st                                 case (isSMT, uiKind) of                                   (True, UICodeC (v, _)) -> sbvToSV st (v arg0 arg1)-                                  _                      -> do newUninterpreted st (nm, Nothing) (SBVType [kc, kb, ka]) =<< retrieveUICode nm st ka uiKind+                                  _                      -> do newUninterpreted st (nm, mbArgs) (SBVType [kc, kb, ka]) =<< retrieveUICode nm st ka uiKind                                                                sw0 <- sbvToSV st arg0                                                                sw1 <- sbvToSV st arg1                                                                mapM_ forceSVArg [sw0, sw1]@@ -2407,7 +2449,9 @@  -- Functions of three arguments instance (SymVal d, SymVal c, SymVal b, HasKind a) => SMTDefinable (SBV d -> SBV c -> SBV b -> SBV a) where-  sbvDefineValue nm uiKind = f+  sbv2smt fn = defs2smt $ \d c b -> fn d c b .== fn d c b++  sbvDefineValue nm mbArgs uiKind = f     where f arg0 arg1 arg2            | Just v <- retrieveConstCode uiKind, isConcrete arg0, isConcrete arg1, isConcrete arg2            = v arg0 arg1 arg2@@ -2420,7 +2464,7 @@                  result st = do isSMT <- inSMTMode st                                 case (isSMT, uiKind) of                                   (True, UICodeC (v, _)) -> sbvToSV st (v arg0 arg1 arg2)-                                  _                      -> do newUninterpreted st (nm, Nothing) (SBVType [kd, kc, kb, ka]) =<< retrieveUICode nm st ka uiKind+                                  _                      -> do newUninterpreted st (nm, mbArgs) (SBVType [kd, kc, kb, ka]) =<< retrieveUICode nm st ka uiKind                                                                sw0 <- sbvToSV st arg0                                                                sw1 <- sbvToSV st arg1                                                                sw2 <- sbvToSV st arg2@@ -2429,7 +2473,9 @@  -- Functions of four arguments instance (SymVal e, SymVal d, SymVal c, SymVal b, HasKind a) => SMTDefinable (SBV e -> SBV d -> SBV c -> SBV b -> SBV a) where-  sbvDefineValue nm uiKind = f+  sbv2smt fn = defs2smt $ \e d c b -> fn e d c b .== fn e d c b++  sbvDefineValue nm mbArgs uiKind = f     where f arg0 arg1 arg2 arg3            | Just v <- retrieveConstCode uiKind, isConcrete arg0, isConcrete arg1, isConcrete arg2, isConcrete arg3            = v arg0 arg1 arg2 arg3@@ -2443,7 +2489,7 @@                  result st = do isSMT <- inSMTMode st                                 case (isSMT, uiKind) of                                   (True, UICodeC (v, _)) -> sbvToSV st (v arg0 arg1 arg2 arg3)-                                  _                      -> do newUninterpreted st (nm, Nothing) (SBVType [ke, kd, kc, kb, ka]) =<< retrieveUICode nm st ka uiKind+                                  _                      -> do newUninterpreted st (nm, mbArgs) (SBVType [ke, kd, kc, kb, ka]) =<< retrieveUICode nm st ka uiKind                                                                sw0 <- sbvToSV st arg0                                                                sw1 <- sbvToSV st arg1                                                                sw2 <- sbvToSV st arg2@@ -2453,7 +2499,9 @@  -- Functions of five arguments instance (SymVal f, SymVal e, SymVal d, SymVal c, SymVal b, HasKind a) => SMTDefinable (SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) where-  sbvDefineValue nm uiKind = f+  sbv2smt fn = defs2smt $ \f e d c b -> fn f e d c b .== fn f e d c b++  sbvDefineValue nm mbArgs uiKind = f     where f arg0 arg1 arg2 arg3 arg4            | Just v <- retrieveConstCode uiKind, isConcrete arg0, isConcrete arg1, isConcrete arg2, isConcrete arg3, isConcrete arg4            = v arg0 arg1 arg2 arg3 arg4@@ -2468,7 +2516,7 @@                  result st = do isSMT <- inSMTMode st                                 case (isSMT, uiKind) of                                   (True, UICodeC (v, _)) -> sbvToSV st (v arg0 arg1 arg2 arg3 arg4)-                                  _                      -> do newUninterpreted st (nm, Nothing) (SBVType [kf, ke, kd, kc, kb, ka]) =<< retrieveUICode nm st ka uiKind+                                  _                      -> do newUninterpreted st (nm, mbArgs) (SBVType [kf, ke, kd, kc, kb, ka]) =<< retrieveUICode nm st ka uiKind                                                                sw0 <- sbvToSV st arg0                                                                sw1 <- sbvToSV st arg1                                                                sw2 <- sbvToSV st arg2@@ -2479,7 +2527,9 @@  -- Functions of six arguments instance (SymVal g, SymVal f, SymVal e, SymVal d, SymVal c, SymVal b, HasKind a) => SMTDefinable (SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) where-  sbvDefineValue nm uiKind = f+  sbv2smt fn = defs2smt $ \f g e d c b -> fn g f e d c b .== fn g f e d c b++  sbvDefineValue nm mbArgs uiKind = f     where f arg0 arg1 arg2 arg3 arg4 arg5            | Just v <- retrieveConstCode uiKind, isConcrete arg0, isConcrete arg1, isConcrete arg2, isConcrete arg3, isConcrete arg4, isConcrete arg5            = v arg0 arg1 arg2 arg3 arg4 arg5@@ -2495,7 +2545,7 @@                  result st = do isSMT <- inSMTMode st                                 case (isSMT, uiKind) of                                   (True, UICodeC (v, _)) -> sbvToSV st (v arg0 arg1 arg2 arg3 arg4 arg5)-                                  _                      -> do newUninterpreted st (nm, Nothing) (SBVType [kg, kf, ke, kd, kc, kb, ka]) =<< retrieveUICode nm st ka uiKind+                                  _                      -> do newUninterpreted st (nm, mbArgs) (SBVType [kg, kf, ke, kd, kc, kb, ka]) =<< retrieveUICode nm st ka uiKind                                                                sw0 <- sbvToSV st arg0                                                                sw1 <- sbvToSV st arg1                                                                sw2 <- sbvToSV st arg2@@ -2508,7 +2558,9 @@ -- Functions of seven arguments instance (SymVal h, SymVal g, SymVal f, SymVal e, SymVal d, SymVal c, SymVal b, HasKind a)             => SMTDefinable (SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) where-  sbvDefineValue nm uiKind = f+  sbv2smt fn = defs2smt $ \h g f e d c b -> fn h g f e d c b .== fn h g f e d c b++  sbvDefineValue nm mbArgs uiKind = f     where f arg0 arg1 arg2 arg3 arg4 arg5 arg6            | Just v <- retrieveConstCode uiKind, isConcrete arg0, isConcrete arg1, isConcrete arg2, isConcrete arg3, isConcrete arg4, isConcrete arg5, isConcrete arg6            = v arg0 arg1 arg2 arg3 arg4 arg5 arg6@@ -2525,7 +2577,7 @@                  result st = do isSMT <- inSMTMode st                                 case (isSMT, uiKind) of                                   (True, UICodeC (v, _)) -> sbvToSV st (v arg0 arg1 arg2 arg3 arg4 arg5 arg6)-                                  _                      -> do newUninterpreted st (nm, Nothing) (SBVType [kh, kg, kf, ke, kd, kc, kb, ka]) =<< retrieveUICode nm st ka uiKind+                                  _                      -> do newUninterpreted st (nm, mbArgs) (SBVType [kh, kg, kf, ke, kd, kc, kb, ka]) =<< retrieveUICode nm st ka uiKind                                                                sw0 <- sbvToSV st arg0                                                                sw1 <- sbvToSV st arg1                                                                sw2 <- sbvToSV st arg2@@ -2536,38 +2588,291 @@                                                                mapM_ forceSVArg [sw0, sw1, sw2, sw3, sw4, sw5, sw6]                                                                newExpr st ka $ SBVApp (Uninterpreted nm) [sw0, sw1, sw2, sw3, sw4, sw5, sw6] +-- Functions of eight arguments+instance (SymVal i, SymVal h, SymVal g, SymVal f, SymVal e, SymVal d, SymVal c, SymVal b, HasKind a)+            => SMTDefinable (SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) where+  sbv2smt fn = defs2smt $ \i h g f e d c b -> fn i h g f e d c b .== fn i h g f e d c b++  sbvDefineValue nm mbArgs uiKind = f+    where f arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7+           | Just v <- retrieveConstCode uiKind, isConcrete arg0, isConcrete arg1, isConcrete arg2, isConcrete arg3, isConcrete arg4, isConcrete arg5, isConcrete arg6, isConcrete arg7+           = v arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7+           | True+           = SBV $ SVal ka $ Right $ cache result+           where ka = kindOf (Proxy @a)+                 kb = kindOf (Proxy @b)+                 kc = kindOf (Proxy @c)+                 kd = kindOf (Proxy @d)+                 ke = kindOf (Proxy @e)+                 kf = kindOf (Proxy @f)+                 kg = kindOf (Proxy @g)+                 kh = kindOf (Proxy @h)+                 ki = kindOf (Proxy @i)+                 result st = do isSMT <- inSMTMode st+                                case (isSMT, uiKind) of+                                  (True, UICodeC (v, _)) -> sbvToSV st (v arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7)+                                  _                      -> do newUninterpreted st (nm, mbArgs) (SBVType [kh, kg, kf, ke, kd, kc, kb, ka, ki]) =<< retrieveUICode nm st ka uiKind+                                                               sw0 <- sbvToSV st arg0+                                                               sw1 <- sbvToSV st arg1+                                                               sw2 <- sbvToSV st arg2+                                                               sw3 <- sbvToSV st arg3+                                                               sw4 <- sbvToSV st arg4+                                                               sw5 <- sbvToSV st arg5+                                                               sw6 <- sbvToSV st arg6+                                                               sw7 <- sbvToSV st arg7+                                                               mapM_ forceSVArg [sw0, sw1, sw2, sw3, sw4, sw5, sw6, sw7]+                                                               newExpr st ka $ SBVApp (Uninterpreted nm) [sw0, sw1, sw2, sw3, sw4, sw5, sw6, sw7]++-- Functions of nine arguments+instance (SymVal j, SymVal i, SymVal h, SymVal g, SymVal f, SymVal e, SymVal d, SymVal c, SymVal b, HasKind a)+            => SMTDefinable (SBV j -> SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) where+  sbv2smt fn = defs2smt $ \j i h g f e d c b -> fn j i h g f e d c b .== fn j i h g f e d c b++  sbvDefineValue nm mbArgs uiKind = f+    where f arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8+           | Just v <- retrieveConstCode uiKind, isConcrete arg0, isConcrete arg1, isConcrete arg2, isConcrete arg3, isConcrete arg4, isConcrete arg5, isConcrete arg6, isConcrete arg7, isConcrete arg8+           = v arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8+           | True+           = SBV $ SVal ka $ Right $ cache result+           where ka = kindOf (Proxy @a)+                 kb = kindOf (Proxy @b)+                 kc = kindOf (Proxy @c)+                 kd = kindOf (Proxy @d)+                 ke = kindOf (Proxy @e)+                 kf = kindOf (Proxy @f)+                 kg = kindOf (Proxy @g)+                 kh = kindOf (Proxy @h)+                 ki = kindOf (Proxy @i)+                 kj = kindOf (Proxy @j)+                 result st = do isSMT <- inSMTMode st+                                case (isSMT, uiKind) of+                                  (True, UICodeC (v, _)) -> sbvToSV st (v arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8)+                                  _                      -> do newUninterpreted st (nm, mbArgs) (SBVType [kh, kg, kf, ke, kd, kc, kb, ka, ki, kj]) =<< retrieveUICode nm st ka uiKind+                                                               sw0 <- sbvToSV st arg0+                                                               sw1 <- sbvToSV st arg1+                                                               sw2 <- sbvToSV st arg2+                                                               sw3 <- sbvToSV st arg3+                                                               sw4 <- sbvToSV st arg4+                                                               sw5 <- sbvToSV st arg5+                                                               sw6 <- sbvToSV st arg6+                                                               sw7 <- sbvToSV st arg7+                                                               sw8 <- sbvToSV st arg8+                                                               mapM_ forceSVArg [sw0, sw1, sw2, sw3, sw4, sw5, sw6, sw7, sw8]+                                                               newExpr st ka $ SBVApp (Uninterpreted nm) [sw0, sw1, sw2, sw3, sw4, sw5, sw6, sw7, sw8]++-- Functions of ten arguments+instance (SymVal k, SymVal j, SymVal i, SymVal h, SymVal g, SymVal f, SymVal e, SymVal d, SymVal c, SymVal b, HasKind a)+            => SMTDefinable (SBV k -> SBV j -> SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) where+  sbv2smt fn = defs2smt $ \k j i h g f e d c b -> fn k j i h g f e d c b .== fn k j i h g f e d c b++  sbvDefineValue nm mbArgs uiKind = f+    where f arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9+           | Just v <- retrieveConstCode uiKind, isConcrete arg0, isConcrete arg1, isConcrete arg2, isConcrete arg3, isConcrete arg4, isConcrete arg5, isConcrete arg6, isConcrete arg7, isConcrete arg8, isConcrete arg9+           = v arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9+           | True+           = SBV $ SVal ka $ Right $ cache result+           where ka = kindOf (Proxy @a)+                 kb = kindOf (Proxy @b)+                 kc = kindOf (Proxy @c)+                 kd = kindOf (Proxy @d)+                 ke = kindOf (Proxy @e)+                 kf = kindOf (Proxy @f)+                 kg = kindOf (Proxy @g)+                 kh = kindOf (Proxy @h)+                 ki = kindOf (Proxy @i)+                 kj = kindOf (Proxy @j)+                 kk = kindOf (Proxy @k)+                 result st = do isSMT <- inSMTMode st+                                case (isSMT, uiKind) of+                                  (True, UICodeC (v, _)) -> sbvToSV st (v arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9)+                                  _                      -> do newUninterpreted st (nm, mbArgs) (SBVType [kh, kg, kf, ke, kd, kc, kb, ka, ki, kj, kk]) =<< retrieveUICode nm st ka uiKind+                                                               sw0 <- sbvToSV st arg0+                                                               sw1 <- sbvToSV st arg1+                                                               sw2 <- sbvToSV st arg2+                                                               sw3 <- sbvToSV st arg3+                                                               sw4 <- sbvToSV st arg4+                                                               sw5 <- sbvToSV st arg5+                                                               sw6 <- sbvToSV st arg6+                                                               sw7 <- sbvToSV st arg7+                                                               sw8 <- sbvToSV st arg8+                                                               sw9 <- sbvToSV st arg9+                                                               mapM_ forceSVArg [sw0, sw1, sw2, sw3, sw4, sw5, sw6, sw7, sw8, sw9]+                                                               newExpr st ka $ SBVApp (Uninterpreted nm) [sw0, sw1, sw2, sw3, sw4, sw5, sw6, sw7, sw8, sw9]++-- Functions of eleven arguments+instance (SymVal l, SymVal k, SymVal j, SymVal i, SymVal h, SymVal g, SymVal f, SymVal e, SymVal d, SymVal c, SymVal b, HasKind a)+            => SMTDefinable (SBV l -> SBV k -> SBV j -> SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) where+  sbv2smt fn = defs2smt $ \l k j i h g f e d c b -> fn l k j i h g f e d c b .== fn l k j i h g f e d c b++  sbvDefineValue nm mbArgs uiKind = f+    where f arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10+           | Just v <- retrieveConstCode uiKind, isConcrete arg0, isConcrete arg1, isConcrete arg2, isConcrete arg3, isConcrete arg4, isConcrete arg5, isConcrete arg6, isConcrete arg7, isConcrete arg8, isConcrete arg9, isConcrete arg10+           = v arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10+           | True+           = SBV $ SVal ka $ Right $ cache result+           where ka = kindOf (Proxy @a)+                 kb = kindOf (Proxy @b)+                 kc = kindOf (Proxy @c)+                 kd = kindOf (Proxy @d)+                 ke = kindOf (Proxy @e)+                 kf = kindOf (Proxy @f)+                 kg = kindOf (Proxy @g)+                 kh = kindOf (Proxy @h)+                 ki = kindOf (Proxy @i)+                 kj = kindOf (Proxy @j)+                 kk = kindOf (Proxy @k)+                 kl = kindOf (Proxy @l)+                 result st = do isSMT <- inSMTMode st+                                case (isSMT, uiKind) of+                                  (True, UICodeC (v, _)) -> sbvToSV st (v arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10)+                                  _                      -> do newUninterpreted st (nm, mbArgs) (SBVType [kh, kg, kf, ke, kd, kc, kb, ka, ki, kj, kk, kl]) =<< retrieveUICode nm st ka uiKind+                                                               sw0  <- sbvToSV st arg0+                                                               sw1  <- sbvToSV st arg1+                                                               sw2  <- sbvToSV st arg2+                                                               sw3  <- sbvToSV st arg3+                                                               sw4  <- sbvToSV st arg4+                                                               sw5  <- sbvToSV st arg5+                                                               sw6  <- sbvToSV st arg6+                                                               sw7  <- sbvToSV st arg7+                                                               sw8  <- sbvToSV st arg8+                                                               sw9  <- sbvToSV st arg9+                                                               sw10 <- sbvToSV st arg10+                                                               mapM_ forceSVArg [sw0, sw1, sw2, sw3, sw4, sw5, sw6, sw7, sw8, sw9, sw10]+                                                               newExpr st ka $ SBVApp (Uninterpreted nm) [sw0, sw1, sw2, sw3, sw4, sw5, sw6, sw7, sw8, sw9, sw10]++-- Functions of twelve arguments+instance (SymVal m, SymVal l, SymVal k, SymVal j, SymVal i, SymVal h, SymVal g, SymVal f, SymVal e, SymVal d, SymVal c, SymVal b, HasKind a)+            => SMTDefinable (SBV m -> SBV l -> SBV k -> SBV j -> SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) where+  sbv2smt fn = defs2smt $ \m l k j i h g f e d c b -> fn m l k j i h g f e d c b .== fn m l k j i h g f e d c b++  sbvDefineValue nm mbArgs uiKind = f+    where f arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10 arg11+           | Just v <- retrieveConstCode uiKind, isConcrete arg0, isConcrete arg1, isConcrete arg2, isConcrete arg3, isConcrete arg4, isConcrete arg5, isConcrete arg6, isConcrete arg7, isConcrete arg8, isConcrete arg9, isConcrete arg10, isConcrete arg11+           = v arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10 arg11+           | True+           = SBV $ SVal ka $ Right $ cache result+           where ka = kindOf (Proxy @a)+                 kb = kindOf (Proxy @b)+                 kc = kindOf (Proxy @c)+                 kd = kindOf (Proxy @d)+                 ke = kindOf (Proxy @e)+                 kf = kindOf (Proxy @f)+                 kg = kindOf (Proxy @g)+                 kh = kindOf (Proxy @h)+                 ki = kindOf (Proxy @i)+                 kj = kindOf (Proxy @j)+                 kk = kindOf (Proxy @k)+                 kl = kindOf (Proxy @l)+                 km = kindOf (Proxy @m)+                 result st = do isSMT <- inSMTMode st+                                case (isSMT, uiKind) of+                                  (True, UICodeC (v, _)) -> sbvToSV st (v arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10 arg11)+                                  _                      -> do newUninterpreted st (nm, mbArgs) (SBVType [kh, kg, kf, ke, kd, kc, kb, ka, ki, kj, kk, kl, km]) =<< retrieveUICode nm st ka uiKind+                                                               sw0  <- sbvToSV st arg0+                                                               sw1  <- sbvToSV st arg1+                                                               sw2  <- sbvToSV st arg2+                                                               sw3  <- sbvToSV st arg3+                                                               sw4  <- sbvToSV st arg4+                                                               sw5  <- sbvToSV st arg5+                                                               sw6  <- sbvToSV st arg6+                                                               sw7  <- sbvToSV st arg7+                                                               sw8  <- sbvToSV st arg8+                                                               sw9  <- sbvToSV st arg9+                                                               sw10 <- sbvToSV st arg10+                                                               sw11 <- sbvToSV st arg11+                                                               mapM_ forceSVArg [sw0, sw1, sw2, sw3, sw4, sw5, sw6, sw7, sw8, sw9, sw10, sw11]+                                                               newExpr st ka $ SBVApp (Uninterpreted nm) [sw0, sw1, sw2, sw3, sw4, sw5, sw6, sw7, sw8, sw9, sw10, sw11]++-- Mark the UIKind as uncurried+mkUncurried :: UIKind a -> UIKind a+mkUncurried (UIFree  _) = UIFree  False+mkUncurried (UIFun   a) = UIFun   a+mkUncurried (UICodeC a) = UICodeC a+ -- Uncurried functions of two arguments instance (SymVal c, SymVal b, HasKind a) => SMTDefinable ((SBV c, SBV b) -> SBV a) where-  sbvDefineValue nm uiKind = let f = sbvDefineValue nm (curry <$> uiKind) in uncurry f+  sbv2smt fn = defs2smt $ \p -> fn p .== fn p +  sbvDefineValue nm mbArgs uiKind = let f = sbvDefineValue nm mbArgs (curry <$> mkUncurried uiKind) in uncurry f+ -- Uncurried functions of three arguments instance (SymVal d, SymVal c, SymVal b, HasKind a) => SMTDefinable ((SBV d, SBV c, SBV b) -> SBV a) where-  sbvDefineValue nm uiKind = let f = sbvDefineValue nm (uc3 <$> uiKind) in \(arg0, arg1, arg2) -> f arg0 arg1 arg2+  sbv2smt fn = defs2smt $ \p -> fn p .== fn p++  sbvDefineValue nm mbArgs uiKind = let f = sbvDefineValue nm mbArgs (uc3 <$> mkUncurried uiKind) in \(arg0, arg1, arg2) -> f arg0 arg1 arg2     where uc3 fn a b c = fn (a, b, c)  -- Uncurried functions of four arguments instance (SymVal e, SymVal d, SymVal c, SymVal b, HasKind a)             => SMTDefinable ((SBV e, SBV d, SBV c, SBV b) -> SBV a) where-  sbvDefineValue nm uiKind = let f = sbvDefineValue nm (uc4 <$> uiKind) in \(arg0, arg1, arg2, arg3) -> f arg0 arg1 arg2 arg3+  sbv2smt fn = defs2smt $ \p -> fn p .== fn p++  sbvDefineValue nm mbArgs uiKind = let f = sbvDefineValue nm mbArgs (uc4 <$> mkUncurried uiKind) in \(arg0, arg1, arg2, arg3) -> f arg0 arg1 arg2 arg3     where uc4 fn a b c d = fn (a, b, c, d)  -- Uncurried functions of five arguments instance (SymVal f, SymVal e, SymVal d, SymVal c, SymVal b, HasKind a)             => SMTDefinable ((SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) where-  sbvDefineValue nm uiKind = let f = sbvDefineValue nm (uc5 <$> uiKind) in \(arg0, arg1, arg2, arg3, arg4) -> f arg0 arg1 arg2 arg3 arg4+  sbv2smt fn = defs2smt $ \p -> fn p .== fn p++  sbvDefineValue nm mbArgs uiKind = let f = sbvDefineValue nm mbArgs (uc5 <$> mkUncurried uiKind) in \(arg0, arg1, arg2, arg3, arg4) -> f arg0 arg1 arg2 arg3 arg4     where uc5 fn a b c d e = fn (a, b, c, d, e)  -- Uncurried functions of six arguments instance (SymVal g, SymVal f, SymVal e, SymVal d, SymVal c, SymVal b, HasKind a)             => SMTDefinable ((SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) where-  sbvDefineValue nm uiKind = let f = sbvDefineValue nm (uc6 <$> uiKind) in \(arg0, arg1, arg2, arg3, arg4, arg5) -> f arg0 arg1 arg2 arg3 arg4 arg5+  sbv2smt fn = defs2smt $ \p -> fn p .== fn p++  sbvDefineValue nm mbArgs uiKind = let f = sbvDefineValue nm mbArgs (uc6 <$> mkUncurried uiKind) in \(arg0, arg1, arg2, arg3, arg4, arg5) -> f arg0 arg1 arg2 arg3 arg4 arg5     where uc6 fn a b c d e f = fn (a, b, c, d, e, f)  -- Uncurried functions of seven arguments instance (SymVal h, SymVal g, SymVal f, SymVal e, SymVal d, SymVal c, SymVal b, HasKind a)             => SMTDefinable ((SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) where-  sbvDefineValue nm uiKind = let f = sbvDefineValue nm (uc7 <$> uiKind) in \(arg0, arg1, arg2, arg3, arg4, arg5, arg6) -> f arg0 arg1 arg2 arg3 arg4 arg5 arg6+  sbv2smt fn = defs2smt $ \p -> fn p .== fn p++  sbvDefineValue nm mbArgs uiKind = let f = sbvDefineValue nm mbArgs (uc7 <$> mkUncurried uiKind) in \(arg0, arg1, arg2, arg3, arg4, arg5, arg6) -> f arg0 arg1 arg2 arg3 arg4 arg5 arg6     where uc7 fn a b c d e f g = fn (a, b, c, d, e, f, g)++-- Uncurried functions of eight arguments+instance (SymVal i, SymVal h, SymVal g, SymVal f, SymVal e, SymVal d, SymVal c, SymVal b, HasKind a)+            => SMTDefinable ((SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) where+  sbv2smt fn = defs2smt $ \p -> fn p .== fn p++  sbvDefineValue nm mbArgs uiKind = let f = sbvDefineValue nm mbArgs (uc8 <$> mkUncurried uiKind) in \(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) -> f arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7+    where uc8 fn a b c d e f g h = fn (a, b, c, d, e, f, g, h)++-- Uncurried functions of nine arguments+instance (SymVal j, SymVal i, SymVal h, SymVal g, SymVal f, SymVal e, SymVal d, SymVal c, SymVal b, HasKind a)+            => SMTDefinable ((SBV j, SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) where+  sbv2smt fn = defs2smt $ \p -> fn p .== fn p++  sbvDefineValue nm mbArgs uiKind = let f = sbvDefineValue nm mbArgs (uc9 <$> mkUncurried uiKind) in \(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) -> f arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8+    where uc9 fn a b c d e f g h i = fn (a, b, c, d, e, f, g, h, i)++-- Uncurried functions of ten arguments+instance (SymVal k, SymVal j, SymVal i, SymVal h, SymVal g, SymVal f, SymVal e, SymVal d, SymVal c, SymVal b, HasKind a)+            => SMTDefinable ((SBV k, SBV j, SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) where+  sbv2smt fn = defs2smt $ \p -> fn p .== fn p++  sbvDefineValue nm mbArgs uiKind = let f = sbvDefineValue nm mbArgs (uc10 <$> mkUncurried uiKind) in \(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) -> f arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9+    where uc10 fn a b c d e f g h i j = fn (a, b, c, d, e, f, g, h, i, j)++-- Uncurried functions of eleven arguments+instance (SymVal l, SymVal k, SymVal j, SymVal i, SymVal h, SymVal g, SymVal f, SymVal e, SymVal d, SymVal c, SymVal b, HasKind a)+            => SMTDefinable ((SBV l, SBV k, SBV j, SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) where+  sbv2smt fn = defs2smt $ \p -> fn p .== fn p++  sbvDefineValue nm mbArgs uiKind = let f = sbvDefineValue nm mbArgs (uc11 <$> mkUncurried uiKind) in \(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10) -> f arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10+    where uc11 fn a b c d e f g h i j k = fn (a, b, c, d, e, f, g, h, i, j, k)++-- Uncurried functions of twelve arguments+instance (SymVal m, SymVal l, SymVal k, SymVal j, SymVal i, SymVal h, SymVal g, SymVal f, SymVal e, SymVal d, SymVal c, SymVal b, HasKind a)+            => SMTDefinable ((SBV m, SBV l, SBV k, SBV j, SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) where+  sbv2smt fn = defs2smt $ \p -> fn p .== fn p++  sbvDefineValue nm mbArgs uiKind = let f = sbvDefineValue nm mbArgs (uc12 <$> mkUncurried uiKind) in \(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11) -> f arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10 arg11+    where uc12 fn a b c d e f g h i j k l = fn (a, b, c, d, e, f, g, h, i, j, k, l)  -- | Symbolic computations provide a context for writing symbolic programs. instance MonadIO m => SolverContext (SymbolicT m) where
Data/SBV/Core/Operations.hs view
@@ -33,7 +33,7 @@   , svSign, svUnsign, svSetBit, svWordFromBE, svWordFromLE   , svExp, svFromIntegral   -- ** Overflows-  , svMkOverflow+  , svMkOverflow1, svMkOverflow2   -- ** Derived operations   , svToWord1, svFromWord1, svTestBit   , svShiftLeft, svShiftRight@@ -897,26 +897,6 @@                                  newExpr st kx (SBVApp op [sw1, adjustedShift]) --- | Generalization of 'svRol', where the rotation amount is symbolic.--- If the first argument is not bounded, then the this is the same as shift.-svRotateLeft :: SVal -> SVal -> SVal-svRotateLeft x i-  | not (isBounded x)-  = svShiftLeft x i-  | isBounded i && bit si <= toInteger sx            -- wrap-around not possible-  = svIte (svLessThan i zi)-          (svSelect [x `svRor` k | k <- [0 .. bit si - 1]] z (svUNeg i))-          (svSelect [x `svRol` k | k <- [0 .. bit si - 1]] z         i)-  | True-  = svIte (svLessThan i zi)-          (svSelect [x `svRor` k | k <- [0 .. sx     - 1]] z (svUNeg i `svRem` n))-          (svSelect [x `svRol` k | k <- [0 .. sx     - 1]] z (       i `svRem` n))-    where sx = intSizeOf x-          si = intSizeOf i-          z  = svInteger (kindOf x) 0-          zi = svInteger (kindOf i) 0-          n  = svInteger (kindOf i) (toInteger sx)- -- | A variant of 'svRotateLeft' that uses a barrel-rotate design, which can lead to -- better verification code. Only works when both arguments are finite and the second -- argument is unsigned.@@ -965,31 +945,97 @@         -- need not look at any position i s.t. 2^i > 32         significant (_, pos) = pos < sa +-- | Generalization of 'svRol', where the rotation amount is symbolic.+-- If the first argument is not bounded, then the this is the same as shift.+svRotateLeft :: SVal -> SVal -> SVal+svRotateLeft = svRotate svShiftLeft svRor svRol+ -- | Generalization of 'svRor', where the rotation amount is symbolic. -- If the first argument is not bounded, then the this is the same as shift. svRotateRight :: SVal -> SVal -> SVal-svRotateRight x i+svRotateRight = svRotate svShiftRight svRol svRor++-- | Common implementation for rotations. This is more complicated than it might first seem, since SMTLib does+-- not allow for non-constant rotation amounts, and only defines rotations for bit-vectors. In SBV, we support+-- both finite/infinite combos, and also non-constant (i.e., symbolic) rotations. Furthermore, if the rotation+-- amount is negative, then the direction of the rotation is reversed.+--+--   Case 1. Infinite x. In this case, we call unbounded-shifter, since you can't rotate an unbounded integer value.+--                       This is the Haskell semantics for rotates.+--   Case 2. Finite x.+--           Case 2.1. Infinite i, or finite i but i can contain a value > |x|. In this case, wrap-around can happen,+--                     so we reduce by the size of |x|.+--           Case 2.2. Finite i, and it can't contain a value > |x|. In this case, no reduction is needed.+svRotate :: (SVal -> SVal -> SVal) -> (SVal -> Int -> SVal) -> (SVal -> Int -> SVal) -> SVal -> SVal -> SVal+svRotate unboundedShifter opRot curRot x i   | not (isBounded x)-  = svShiftRight x i-  | isBounded i && bit si <= toInteger sx                   -- wrap-around not possible-  = svIte (svLessThan i zi)-          (svSelect [x `svRol` k | k <- [0 .. bit si - 1]] z (svUNeg i))-          (svSelect [x `svRor` k | k <- [0 .. bit si - 1]] z         i)+  = unboundedShifter x i   | True-  = svIte (svLessThan i zi)-          (svSelect [x `svRol` k | k <- [0 .. sx     - 1]] z (svUNeg i `svRem` n))-          (svSelect [x `svRor` k | k <- [0 .. sx     - 1]] z (       i `svRem` n))-    where sx = intSizeOf x-          si = intSizeOf i-          z  = svInteger (kindOf x) 0-          zi = svInteger (kindOf i) 0-          n  = svInteger (kindOf i) (toInteger sx)+  = svSelect table (svInteger (kindOf x) 0) curRotate+ where sx = intSizeOf x+       si = intSizeOf i +       -- Is it the case that this rotation can never "wrap-around?" This happens if+       -- i is bounded and the max rotation it can represent is less than the bit-size of the input+       noWrapAround :: Bool+       noWrapAround = isBounded i && maxRotate <= toInteger sx+         where maxRotate :: Integer+               maxRotate+                 | hasSign i = 2^(si-1)+                 | True      = 2^si-1++       ifNegRotate = svIte (svLessThan i (svInteger (kindOf i) 0))++       -- the lookup table has sx entries if index can wrap-around. Otherwise it is just as wide as it needs to be.+       table :: [SVal]+       table = map rotK vals+         where rotK k = ifNegRotate (x `opRot` k) (x `curRot` k)+               vals | noWrapAround = if hasSign i+                                        then -- If signed then bit (si-1) is the max abs value. (consider 3 bits, [-4..3] is the range)+                                             [0 .. bit (si - 1)]+                                        else [0 .. bit si  - 1]+                    | True  -- If wrap-around can happen, then compute all rotations up to |x|+                    = [0 .. sx - 1]++       -- What's the current rotation amount? Here we change the type of the+       -- index to make it one bit larger if the index is signed, since otherwise+       -- we run into (-(-1)) = -1 problem. See https://github.com/LeventErkok/sbv/issues/673#issuecomment-1782296700+       -- Note that curRotate is always non-negative.+       curRotate :: SVal+       curRotate+         | noWrapAround = ifNegRotate (svUNeg i'          ) i'+         | True         = ifNegRotate (svUNeg i' `svRem` n) (i' `svRem` n)++         where i' | hasSign i && isBounded i = toWord $ svAbs $ enlarge i+                  | True                     = i++               -- Make sure sx can fit into this many bits+               si' = (si + 1) `max` bitsNeeded sx++               enlarge+                 | isBounded i = svFromIntegral (KBounded True  si')  -- Increase bit size+                 | True        = id+               toWord+                 | isBounded i = svFromIntegral (KBounded False si')  -- Treat as word, after call to svAbs above+                 | True        = id++               n = svInteger (kindOf i') (toInteger sx)++               bitsNeeded :: Int -> Int+               bitsNeeded = go 0+                 where go s 0 = s+                       go s v = let s' = s + 1 in s' `seq` go s' (v `shiftR` 1)+ -------------------------------------------------------------------------------- -- | Overflow detection.-svMkOverflow :: OvOp -> SVal -> SVal -> SVal-svMkOverflow o x y = SVal KBool (Right (cache r))+svMkOverflow1 :: OvOp -> SVal -> SVal+svMkOverflow1 o x = SVal KBool (Right (cache r))     where r st = do sx <- svToSV st x+                    newExpr st KBool $ SBVApp (OverflowOp o) [sx]++svMkOverflow2 :: OvOp -> SVal -> SVal -> SVal+svMkOverflow2 o x y = SVal KBool (Right (cache r))+    where r st = do sx <- svToSV st x                     sy <- svToSV st y                     newExpr st KBool $ SBVApp (OverflowOp o) [sx, sy] @@ -1005,6 +1051,10 @@ readSArr (SArr (_, bk) f) a = SVal bk $ Right $ cache r   where r st = do arr <- uncacheAI f st                   i   <- svToSV st a++                  let actx = unArrayContext arr+                  checkCompatibleContext actx (contextOfSV i)+                   newExpr st bk (SBVApp (ArrRead arr) [i])  -- | Update the element at @a@ to be @b@@@ -1015,7 +1065,11 @@                   val  <- svToSV st b                   amap <- R.readIORef (rArrayMap st) -                  let j   = ArrayIndex $ IMap.size amap+                  let actx = unArrayContext arr+                  checkCompatibleContext actx (contextOfSV addr)+                  checkCompatibleContext actx (contextOfSV val)++                  let j   = ArrayIndex (IMap.size amap) actx                       upd = IMap.insert (unArrayIndex j) ("array_" ++ show j, ainfo, ArrayMutate arr addr val)                    j `seq` modifyState st rArrayMap upd $ modifyIncState st rNewArrs upd@@ -1029,9 +1083,15 @@   where h st = do ai <- uncacheAI a st                   bi <- uncacheAI b st                   ts <- svToSV st t++                  let ctx = sbvContext st+                  checkCompatibleContext (unArrayContext ai) ctx+                  checkCompatibleContext (unArrayContext bi) ctx+                  checkCompatibleContext (contextOfSV    ts) ctx+                   amap <- R.readIORef (rArrayMap st) -                  let k   = ArrayIndex $ IMap.size amap+                  let k   = ArrayIndex (IMap.size amap) (sbvContext st)                       upd = IMap.insert (unArrayIndex k) ("array_" ++ show k, ainfo, ArrayMerge ts ai bi)                    k `seq` modifyState st rArrayMap upd $ modifyIncState st rNewArrs upd@@ -1048,7 +1108,7 @@                                 Just sv -> Left . Just <$> svToSV st sv                  Right lam -> pure (Right lam) -    let i   = ArrayIndex $ IMap.size amap+    let i   = ArrayIndex (IMap.size amap) (sbvContext st)         nm  = mkNm (unArrayIndex i)         upd = IMap.insert (unArrayIndex i) (nm, ainfo, ArrayFree mbSWDef)
Data/SBV/Core/SizedFloats.hs view
@@ -9,6 +9,7 @@ -- Type-level sized floats. ----------------------------------------------------------------------------- +{-# LANGUAGE DeriveDataTypeable   #-} {-# LANGUAGE DataKinds            #-} {-# LANGUAGE FlexibleInstances    #-} {-# LANGUAGE ScopedTypeVariables  #-}@@ -47,6 +48,8 @@ import LibBF (BigFloat, BFOpts, RoundMode, Status) import qualified LibBF as BF +import qualified Data.Generics as G+ -- | A floating point value, indexed by its exponent and significand sizes. -- --   An IEEE SP is @FloatingPoint  8 24@@@ -84,7 +87,7 @@              , fpSignificandSize :: Int              , fpValue           :: BigFloat              }-             deriving (Ord, Eq)+             deriving (Ord, Eq, G.Data)  instance Show FP where   show = bfRemoveRedundantExp . bfToString 10 False False
Data/SBV/Core/Symbolic.hs view
@@ -24,6 +24,7 @@ {-# LANGUAGE PatternGuards              #-} {-# LANGUAGE Rank2Types                 #-} {-# LANGUAGE ScopedTypeVariables        #-}+{-# LANGUAGE StandaloneDeriving         #-} {-# LANGUAGE TypeFamilies               #-} {-# LANGUAGE TypeOperators              #-} {-# LANGUAGE UndecidableInstances       #-}@@ -33,10 +34,10 @@  module Data.SBV.Core.Symbolic   ( NodeId(..)-  , SV(..), swKind, trueSV, falseSV+  , SV(..), swKind, trueSV, falseSV, contextOfSV   , Op(..), PBOp(..), OvOp(..), FPOp(..), NROp(..), StrOp(..), RegExOp(..), SeqOp(..), SetOp(..), SpecialRelOp(..)   , RegExp(..), regExpToSMTString-  , Quantifier(..), needsExistentials, VarContext(..)+  , Quantifier(..), needsExistentials, SBVContext(..), checkCompatibleContext, VarContext(..)   , RoundingMode(..)   , SBVType(..), svUninterpreted, svUninterpretedNamedArgs, newUninterpreted   , SVal(..)@@ -75,14 +76,17 @@ import Control.Monad.Writer.Strict (MonadWriter) import Data.Char                   (isAlpha, isAlphaNum, toLower) import Data.IORef                  (IORef, newIORef, readIORef)-import Data.List                   (intercalate, sortBy, isPrefixOf)+import Data.List                   (intercalate, sortBy, isPrefixOf, isSuffixOf, nub) import Data.Maybe                  (fromMaybe, mapMaybe) import Data.String                 (IsString(fromString)) import Data.Kind                   (Type)  import Data.Time (getCurrentTime, UTCTime) +import Data.Int (Int64)+ import GHC.Stack+import GHC.Stack.Types import GHC.Generics (Generic)  import qualified Control.Monad.State.Lazy    as LS@@ -91,6 +95,7 @@ import qualified Control.Monad.Writer.Strict as SW import qualified Data.IORef                  as R    (modifyIORef') import qualified Data.Generics               as G    (Data(..))+import qualified Data.Generics.Uniplate.Data as G import qualified Data.IntMap.Strict          as IMap (IntMap, empty, toAscList, lookup, insertWith) import qualified Data.Map.Strict             as Map  (Map, empty, toList, lookup, insert, size) import qualified Data.Set                    as Set  (Set, empty, toList, insert, member)@@ -99,6 +104,7 @@ import qualified Data.Text                   as T  import System.Mem.StableName+import System.Random  import Data.SBV.Core.Kind import Data.SBV.Core.Concrete@@ -112,13 +118,33 @@ import Control.Monad.Fail as Fail #endif +-- | Context identifier. 0 is reserved global context+newtype SBVContext = SBVContext Int64 deriving (Eq, Ord, G.Data, Show)++instance NFData SBVContext where+  rnf (SBVContext i) = i `seq` ()++-- | Global context+globalSBVContext :: SBVContext+globalSBVContext = SBVContext 0++-- | Generate context. We make sure it isn't 0, i.e., the global context+-- The "hope" here is that each time we call this we get a different context number.+-- A random number doesn't necessarily have to do that, but I think the pseudo-generator+-- has a large enough period for this to go through OK.+genSBVContext :: IO SBVContext+genSBVContext = do ctx <- SBVContext <$> randomIO+                   if ctx == globalSBVContext   -- unlikely, but possible+                      then genSBVContext+                      else pure ctx+ -- | A symbolic node id-newtype NodeId = NodeId { getId :: (Int, Int) } -- Lambda-level, and node-id+newtype NodeId = NodeId { getId :: (SBVContext, Int, Int) } -- Lambda-level, and node-id   deriving (Ord, G.Data)  -- Equality is pair-wise, except we accommodate for negative node-id; which is reserved for true/false instance Eq NodeId where-  NodeId n1@(_, i) == NodeId n2@(_, j)+  NodeId n1@(_, _, i) == NodeId n2@(_, _, j)      | i < 0 && j < 0      = i == j      | True@@ -128,6 +154,10 @@ data SV = SV !Kind !NodeId         deriving G.Data +-- | Which context are we using this var at?+contextOfSV :: SV -> SBVContext+contextOfSV (SV _ (NodeId (c, _, _))) = c+ -- | For equality, we merely use the lambda-level/node-id instance Eq SV where   SV _ n1 == SV _ n2 = n1 == n2@@ -140,10 +170,10 @@   kindOf (SV k _) = k  instance Show SV where-  show (SV _ (NodeId (l, n))) = case n of-                                 -2 -> "false"-                                 -1 -> "true"-                                 _  -> prefix ++ 's' : show n+  show (SV _ (NodeId (_, l, n))) = case n of+                                     -2 -> "false"+                                     -1 -> "true"+                                     _  -> prefix ++ 's' : show n         where prefix = case l of                          0 -> ""                          _ -> 'l' : show l ++ "_"@@ -164,11 +194,11 @@  -- | Constant False as an 'SV'. Note that this value always occupies slot -2 and level 0. falseSV :: SV-falseSV = SV KBool $ NodeId (0, -2)+falseSV = SV KBool $ NodeId (globalSBVContext, 0, -2)  -- | Constant True as an 'SV'. Note that this value always occupies slot -1 and level 0. trueSV :: SV-trueSV  = SV KBool $ NodeId (0, -1)+trueSV  = SV KBool $ NodeId (globalSBVContext, 0, -1)  -- | Symbolic operations data Op = Plus@@ -336,16 +366,20 @@           deriving (Eq, Ord, Show, G.Data)  -- | Overflow operations-data OvOp = Overflow_SMul_OVFL   -- ^ Signed multiplication overflow-          | Overflow_SMul_UDFL   -- ^ Signed multiplication underflow-          | Overflow_UMul_OVFL   -- ^ Unsigned multiplication overflow+data OvOp = PlusOv Bool           -- ^ Addition    overflow.    Bool is True if signed.+          | SubOv  Bool           -- ^ Subtraction overflow.    Bool is True if signed.+          | MulOv  Bool           -- ^ Multiplication overflow. Bool is True if signed.+          | DivOv                 -- ^ Division overflow.       Only signed, since unsigned division does not overflow.+          | NegOv                 -- ^ Unary negation overflow. Only signed, since unsigned negation does not overflow.           deriving (Eq, Ord, G.Data) --- | Show instance. It's important that these follow the internal z3 names+-- | Show instance. It's important that these follow the SMTLib names. instance Show OvOp where-  show Overflow_SMul_OVFL = "bvsmul_noovfl"-  show Overflow_SMul_UDFL = "bvsmul_noudfl"-  show Overflow_UMul_OVFL = "bvumul_noovfl"+  show (PlusOv signed) = "bv" ++ (if signed then "s" else "u") ++ "addo"+  show (SubOv  signed) = "bv" ++ (if signed then "s" else "u") ++ "subo"+  show (MulOv  signed) = "bv" ++ (if signed then "s" else "u") ++ "mulo"+  show DivOv           = "bvsdivo" -- This is confusing, the division is called bvsdivo, but negation is bvnego+  show NegOv           = "bvnego"  -- But SMTLib's choice is deliberate: https://groups.google.com/u/0/g/smt-lib/c/J4D99wT0aKI  -- | String operations. Note that we do not define @StrAt@ as it translates to 'StrSubstr' trivially. data StrOp = StrConcat       -- ^ Concatenation of one or more strings@@ -531,7 +565,6 @@            | SetSubset            | SetDifference            | SetComplement-           | SetHasSize         deriving (Eq, Ord, G.Data)  -- The show instance for 'SetOp' is merely for debugging, we map them separately so@@ -546,7 +579,6 @@   show SetSubset     = "Set.subset"   show SetDifference = "Set.difference"   show SetComplement = "Set.complement"-  show SetHasSize    = "Set.setHasSize"  -- Show instance for 'Op'. Note that this is largely for debugging purposes, not used -- for being read by any tool.@@ -619,7 +651,7 @@                  ]  -- | Quantifiers: forall or exists. Note that we allow arbitrary nestings.-data Quantifier = ALL | EX deriving Eq+data Quantifier = ALL | EX deriving (Eq, G.Data)  -- | Show instance for 'Quantifier' instance Show Quantifier where@@ -638,7 +670,7 @@ -- We keep track of the signedness/size of the arguments. A non-function will -- have just one entry in the list. newtype SBVType = SBVType [Kind]-             deriving (Eq, Ord)+                deriving (Eq, Ord, G.Data)  instance Show SBVType where   show (SBVType []) = error "SBV: internal error, empty SBVType"@@ -671,13 +703,14 @@  -- | A program is a sequence of assignments newtype SBVPgm = SBVPgm {pgmAssignments :: S.Seq (SV, SBVExpr)}+               deriving G.Data  -- | Helper synonym for text, in case we switch to something else later. type Name = T.Text  -- | 'NamedSymVar' pairs symbolic values and user given/automatically generated names data NamedSymVar = NamedSymVar !SV !Name-                 deriving (Show, Generic)+                 deriving (Show, Generic, G.Data)  -- | For comparison purposes, we simply use the SV and ignore the name instance Eq NamedSymVar where@@ -826,6 +859,7 @@ -- | A result can either produce something at the top or as a lambda/constraint. Distinguish by inputs data ResultInp = ResultTopInps ([NamedSymVar], [NamedSymVar])  -- user inputs -- trackers                | ResultLamInps [(Quantifier, NamedSymVar)]     -- for constraints, we can have quantifiers+               deriving G.Data  instance NFData ResultInp where    rnf (ResultTopInps xs) = rnf xs@@ -836,10 +870,14 @@                          , progSpecialRels   :: [SpecialRelOp]                          , progTransClosures :: [(String, String)]                          }+                         deriving G.Data  instance NFData ProgInfo where    rnf (ProgInfo a b c) = rnf a `seq` rnf b `seq` rnf c +deriving instance G.Data CallStack+deriving instance G.Data SrcLoc+ -- | Result of running a symbolic computation data Result = Result { progInfo       :: ProgInfo                                     -- ^ various info we collect about the program                      , reskinds       :: Set.Set Kind                                 -- ^ kinds used in the program@@ -850,13 +888,14 @@                      , resConsts      :: (CnstMap, [(SV, CV)])                        -- ^ constants                      , resTables      :: [((Int, Kind, Kind), [SV])]                  -- ^ tables (automatically constructed) (tableno, index-type, result-type) elts                      , resArrays      :: [(Int, ArrayInfo)]                           -- ^ arrays (user specified)-                     , resUIConsts    :: [(String, (Maybe [String], SBVType))]        -- ^ uninterpreted constants-                     , resDefinitions :: [SMTDef]                                     -- ^ definitions created via smtFunction or lambda+                     , resUIConsts    :: [(String, (Bool, Maybe [String], SBVType))]  -- ^ uninterpreted constants+                     , resDefinitions :: [(SMTDef, SBVType)]                          -- ^ definitions created via smtFunction or lambda                      , resAsgns       :: SBVPgm                                       -- ^ assignments                      , resConstraints :: S.Seq (Bool, [(String, String)], SV)         -- ^ additional constraints (boolean)                      , resAssertions  :: [(String, Maybe CallStack, SV)]              -- ^ assertions                      , resOutputs     :: [SV]                                         -- ^ outputs                      }+                     deriving G.Data  -- Show instance for 'Result'. Only for debugging purposes. instance Show Result where@@ -946,6 +985,7 @@ data ArrayContext = ArrayFree   (Either (Maybe SV) String) -- ^ A new array, the contents are initialized with the given value, if any, or the custom lambda given                   | ArrayMutate ArrayIndex SV SV           -- ^ An array created by mutating another array at a given cell                   | ArrayMerge  SV ArrayIndex ArrayIndex   -- ^ An array created by symbolically merging two other arrays+                  deriving G.Data  instance Show ArrayContext where   show (ArrayFree (Left Nothing))   = " initialized with random elements"@@ -973,7 +1013,7 @@ type ArrayMap = IMap.IntMap ArrayInfo  -- | Uninterpreted-constants generated during a symbolic run-type UIMap = Map.Map String (Maybe [String], SBVType)+type UIMap = Map.Map String (Bool, Maybe [String], SBVType)   -- If Bool is true, then this is a curried function  -- | Code-segments for Uninterpreted-constants, as given by the user type CgMap = Map.Map String [String]@@ -1139,13 +1179,13 @@    | l == 0 = res    | True   = Nothing  -- l != 0, a lambda var, so we ignore   where-    (l, i) = getId (swNodeId sv)-    svs    = fmap f ns-    res    = case S.lookup i ns of -- Nothing on negative Int or Int > length seq-               Nothing    -> secondLookup-               x@(Just e) -> if sv == f e then x else secondLookup-                 -- we try the fast lookup first, if the node ids don't match then-                 -- we use the more expensive O (n) to find the index and the elem+    (_, l, i) = getId (swNodeId sv)+    svs       = fmap f ns+    res       = case S.lookup i ns of -- Nothing on negative Int or Int > length seq+                  Nothing    -> secondLookup+                  x@(Just e) -> if sv == f e then x else secondLookup+                    -- we try the fast lookup first, if the node ids don't match then+                    -- we use the more expensive O (n) to find the index and the elem     secondLookup = S.elemIndexL sv svs >>= flip S.lookup ns  -- | A defined function/value@@ -1158,6 +1198,7 @@                      [String]         -- ^ Anonymous function -- other definitions it refers to                      (Maybe String)   -- ^ parameter string                      (Int -> String)  -- ^ Body, in SMTLib syntax, given the tab amount+            deriving G.Data  -- | For debug purposes instance Show SMTDef where@@ -1183,38 +1224,40 @@   rnf (SMTLam   fk frees params body) =             rnf fk `seq` rnf frees `seq` rnf params `seq` rnf body  -- | The state of the symbolic interpreter-data State  = State { pathCond     :: SVal                             -- ^ kind KBool-                    , stCfg        :: SMTConfig-                    , startTime    :: UTCTime-                    , rProgInfo    :: IORef ProgInfo-                    , runMode      :: IORef SBVRunMode-                    , rIncState    :: IORef IncState-                    , rCInfo       :: IORef [(String, CV)]-                    , rObservables :: IORef (S.Seq (Name, CV -> Bool, SV))-                    , rctr         :: IORef Int-                    , rLambdaLevel :: IORef Int-                    , rUsedKinds   :: IORef KindSet-                    , rUsedLbls    :: IORef (Set.Set String)-                    , rinps        :: IORef Inputs-                    , rlambdaInps  :: IORef LambdaInputs-                    , rConstraints :: IORef (S.Seq (Bool, [(String, String)], SV))-                    , routs        :: IORef [SV]-                    , rtblMap      :: IORef TableMap-                    , spgm         :: IORef SBVPgm-                    , rconstMap    :: IORef CnstMap-                    , rexprMap     :: IORef ExprMap-                    , rArrayMap    :: IORef ArrayMap-                    , rUIMap       :: IORef UIMap-                    , rUserFuncs   :: IORef (Set.Set String) -- Functions that the user wanted explicit code generation for-                    , rCgMap       :: IORef CgMap-                    , rDefns       :: IORef [SMTDef]-                    , rSMTOptions  :: IORef [SMTOption]-                    , rOptGoals    :: IORef [Objective (SV, SV)]-                    , rAsserts     :: IORef [(String, Maybe CallStack, SV)]-                    , rSVCache     :: IORef (Cache SV)-                    , rAICache     :: IORef (Cache ArrayIndex)-                    , rQueryState  :: IORef (Maybe QueryState)-                    , parentState  :: Maybe State  -- Pointer to our parent if we're in a sublevel+data State  = State { sbvContext     :: SBVContext+                    , pathCond       :: SVal                             -- ^ kind KBool+                    , stCfg          :: SMTConfig+                    , startTime      :: UTCTime+                    , rProgInfo      :: IORef ProgInfo+                    , runMode        :: IORef SBVRunMode+                    , rIncState      :: IORef IncState+                    , rCInfo         :: IORef [(String, CV)]+                    , rObservables   :: IORef (S.Seq (Name, CV -> Bool, SV))+                    , rctr           :: IORef Int+                    , rLambdaLevel   :: IORef Int+                    , rUsedKinds     :: IORef KindSet+                    , rUsedLbls      :: IORef (Set.Set String)+                    , rinps          :: IORef Inputs+                    , rlambdaInps    :: IORef LambdaInputs+                    , rConstraints   :: IORef (S.Seq (Bool, [(String, String)], SV))+                    , rPartitionVars :: IORef [String]+                    , routs          :: IORef [SV]+                    , rtblMap        :: IORef TableMap+                    , spgm           :: IORef SBVPgm+                    , rconstMap      :: IORef CnstMap+                    , rexprMap       :: IORef ExprMap+                    , rArrayMap      :: IORef ArrayMap+                    , rUIMap         :: IORef UIMap+                    , rUserFuncs     :: IORef (Set.Set String) -- Functions that the user wanted explicit code generation for+                    , rCgMap         :: IORef CgMap+                    , rDefns         :: IORef [(SMTDef, SBVType)]+                    , rSMTOptions    :: IORef [SMTOption]+                    , rOptGoals      :: IORef [Objective (SV, SV)]+                    , rAsserts       :: IORef [(String, Maybe CallStack, SV)]+                    , rSVCache       :: IORef (Cache SV)+                    , rAICache       :: IORef (Cache ArrayIndex)+                    , rQueryState    :: IORef (Maybe QueryState)+                    , parentState    :: Maybe State  -- Pointer to our parent if we're in a sublevel                     }  -- | Chase to the root state. No infinite chains!@@ -1326,7 +1369,7 @@ {-# INLINE incrementInternalCounter #-}  -- | Kind of code we have for uninterpretation-data UICodeKind = UINone          -- no code+data UICodeKind = UINone Bool     -- no code. If bool is true, then curried.                 | UISMT  SMTDef   -- SMTLib, first argument are the free-variables in it                 | UICgC  [String] -- Code-gen, currently only C @@ -1354,31 +1397,35 @@ -- | Create a new uninterpreted symbol, possibly with user given code newUninterpreted :: State -> (String, Maybe [String]) -> SBVType -> UICodeKind -> IO () newUninterpreted st (nm, mbArgNames) t uiCode-  | not isInternal && (null nm || not enclosed && (not (isAlpha (head nm)) || not (all validChar (tail nm))))+  | not (isInternal || case nm of+                         []   -> False+                         h:tl -> enclosed || (isAlpha h && all validChar tl))   = error $ "Bad uninterpreted constant name: " ++ show nm ++ ". Must be a valid SMTLib identifier."   | True   = do uiMap <- readIORef (rUIMap st) -       () <- case uiCode of-               UINone  -> pure ()-               UISMT d -> modifyState st rDefns (\defs -> d : filter (\o -> smtDefGivenName o /= Just nm) defs)-                            $ noInteractive [ "Defined functions (smtFunction):"-                                            , "  Name: " ++ nm-                                            , "  Type: " ++ show t-                                            , ""-                                            , "You should use these functions at least once the query part starts"-                                            , "and then use them in the query section as usual."-                                            ]-               UICgC c -> -- No need to record the code in interactive mode: CodeGen doesn't use interactive-                          modifyState st rCgMap (Map.insert nm c) (return ())+       isCurried <- case uiCode of+                      UINone c -> pure c+                      UISMT d  -> do modifyState st rDefns (\defs -> (d, t) : filter (\(o, _) -> smtDefGivenName o /= Just nm) defs)+                                       $ noInteractive [ "Defined functions (smtFunction):"+                                                       , "  Name: " ++ nm+                                                       , "  Type: " ++ show t+                                                       , ""+                                                       , "You should use these functions at least once the query part starts"+                                                       , "and then use them in the query section as usual."+                                                       ]+                                     pure True+                      UICgC c  -> -- No need to record the code in interactive mode: CodeGen doesn't use interactive+                                  do modifyState st rCgMap (Map.insert nm c) (return ())+                                     pure True         case nm `Map.lookup` uiMap of-         Just (_, t') -> checkType t' (return ())-         Nothing      -> modifyState st rUIMap (Map.insert nm (mbArgNames, t))-                           $ modifyIncState st rNewUIs-                                              (\newUIs -> case nm `Map.lookup` newUIs of-                                                            Just (_, t') -> checkType t' newUIs-                                                            Nothing      -> Map.insert nm (mbArgNames, t) newUIs)+         Just (_, _, t') -> checkType t' (return ())+         Nothing         -> modifyState st rUIMap (Map.insert nm (isCurried, mbArgNames, t))+                              $ modifyIncState st rNewUIs+                                                 (\newUIs -> case nm `Map.lookup` newUIs of+                                                               Just (_, _, t') -> checkType t' newUIs+                                                               Nothing         -> Map.insert nm (isCurried, mbArgNames, t) newUIs)   where checkType :: SBVType -> r -> r         checkType t' cont           | t /= t' = error $  "Uninterpreted constant " ++ show nm ++ " used at incompatible types\n"@@ -1387,7 +1434,10 @@           | True    = cont          validChar x = isAlphaNum x || x `elem` ("_" :: String)-        enclosed    = head nm == '|' && last nm == '|' && length nm > 2 && not (any (`elem` ("|\\" :: String)) (tail (init nm)))+        enclosed    =  "|" `isPrefixOf` nm+                    && "|" `isSuffixOf` nm+                    && length nm > 2+                    && not (any (`elem` ("|\\" :: String)) (drop 1 (init nm)))          -- let internal names go through         isInternal = "__internal_sbv_" `isPrefixOf` nm@@ -1427,7 +1477,7 @@ newSV :: State -> Kind -> IO NamedSymVar newSV st k = do ctr <- incrementInternalCounter st                 ll  <- readIORef (rLambdaLevel st)-                let sv = SV k (NodeId (ll, ctr))+                let sv = SV k (NodeId (sbvContext st, ll, ctr))                 registerKind st k                 return $ NamedSymVar sv $ T.pack (show sv) {-# INLINE newSV #-}@@ -1544,12 +1594,39 @@      -- <http://github.com/GaloisInc/cryptol/issues/566> as an example.      Just sv | kindOf sv == k -> return sv      _                        -> do (NamedSymVar sv _) <- newSV st k+                                    checkConsistent sv e                                     let append (SBVPgm xs) = SBVPgm (xs S.|> (sv, e))                                     modifyState st spgm append $ modifyIncState st rNewAsgns append                                     modifyState st rexprMap (Map.insert e sv) (return ())                                     return sv {-# INLINE newExpr #-} +-- | In rare cases, we can get a context mismatch; so make sure the expression is well-formed.+-- This isn't a full solution, but handles the common case (hopefully!)+checkConsistent :: SV -> SBVExpr -> IO ()+checkConsistent lhs (SBVApp _ args) = mapM_ check args+   where SV _ (NodeId (lhsContext, lambdaLevel, lhsId)) = lhs+         check (SV _ (NodeId (rhsContext, ll, ni)))+           | lhsContext `compatibleContext` rhsContext && lambdaLevel >= ll && (lambdaLevel /= ll || lhsId > ni)+           = pure ()+           | True+           = contextMismatchError lhsContext rhsContext (Just (lambdaLevel, lhsId)) (Just (ll, ni))+{-# INLINE checkConsistent #-}++-- | Are these compatible contexts? Either the same, or one of them is global+compatibleContext :: SBVContext -> SBVContext -> Bool+compatibleContext c1 c2 = c1 == c2 || c1 == globalSBVContext || c2 == globalSBVContext+{-# INLINE compatibleContext #-}++-- | Same as checkConsistent above, except in an array context+checkCompatibleContext :: SBVContext -> SBVContext -> IO ()+checkCompatibleContext ctx1 ctx2+   | ctx1 `compatibleContext` ctx2+   = pure ()+   | True+   = contextMismatchError ctx1 ctx2 Nothing Nothing+{-# INLINE checkCompatibleContext #-}+ -- | Convert a symbolic value to an internal SV svToSV :: State -> SVal -> IO SV svToSV st (SVal _ (Left c))  = newConst st c@@ -1702,7 +1779,12 @@                                    let nm = fromMaybe (T.unpack internalName) mbNm                                        nsv = toNamedSV' sv nm -                                       cv = case [v | (nsv', v) <- env, nsv == nsv'] of+                                       -- Ignore the context equivalence check here. When validating, we are in a different+                                       -- context; so they won't match+                                       same (NamedSymVar (SV _ (NodeId (_, ll1, li1))) _)+                                            (NamedSymVar (SV _ (NodeId (_, ll2, li2))) _) = (ll1, li1) == (ll2, li2)++                                       cv = case [v | (nsv', v) <- env, nsv `same` nsv'] of                                               []    -> if isTracker                                                        then  -- The sole purpose of a tracker variable is to send the optimization                                                              -- directive to the solver, so we can name "expressions" that are minimized@@ -1760,7 +1842,9 @@          -- Also, the following will fail if we span the range of integers without finding a match, but your computer would          -- die way ahead of that happening if that's the case!          mkUnique :: T.Text -> Set.Set Name -> T.Text-         mkUnique prefix names = head $ dropWhile (`Set.member` names) (prefix : [prefix <> "_" <> T.pack (show i) | i <- [(0::Int)..]])+         mkUnique prefix names = case dropWhile (`Set.member` names) (prefix : [prefix <> "_" <> T.pack (show i) | i <- [(0::Int)..]]) of+                                   h:_ -> h+                                   _   -> error $ "mkUnique: Impossible happened! Couldn't get a unique name for " ++ show (prefix, names)  -- | Create a new state mkNewState :: MonadIO m => SMTConfig -> SBVRunMode -> m State@@ -1796,43 +1880,47 @@      usedKinds  <- newIORef Set.empty      usedLbls   <- newIORef Set.empty      cstrs      <- newIORef S.empty+     pvs        <- newIORef []      smtOpts    <- newIORef []      optGoals   <- newIORef []      asserts    <- newIORef []      istate     <- newIORef =<< newIncState      qstate     <- newIORef Nothing-     pure $ State { runMode      = rm-                  , stCfg        = cfg-                  , startTime    = currTime-                  , rProgInfo    = progInfo-                  , pathCond     = SVal KBool (Left trueCV)-                  , rIncState    = istate-                  , rCInfo       = cInfo-                  , rObservables = observes-                  , rctr         = ctr-                  , rLambdaLevel = lambda-                  , rUsedKinds   = usedKinds-                  , rUsedLbls    = usedLbls-                  , rinps        = inps-                  , rlambdaInps  = lambdaInps-                  , routs        = outs-                  , rtblMap      = tables-                  , spgm         = pgm-                  , rconstMap    = cmap-                  , rArrayMap    = arrays-                  , rexprMap     = emap-                  , rUserFuncs   = userFuncs-                  , rUIMap       = uis-                  , rCgMap       = cgs-                  , rDefns       = defns-                  , rSVCache     = swCache-                  , rAICache     = aiCache-                  , rConstraints = cstrs-                  , rSMTOptions  = smtOpts-                  , rOptGoals    = optGoals-                  , rAsserts     = asserts-                  , rQueryState  = qstate-                  , parentState  = Nothing+     ctx        <- genSBVContext+     pure $ State { sbvContext     = ctx+                  , runMode        = rm+                  , stCfg          = cfg+                  , startTime      = currTime+                  , rProgInfo      = progInfo+                  , pathCond       = SVal KBool (Left trueCV)+                  , rIncState      = istate+                  , rCInfo         = cInfo+                  , rObservables   = observes+                  , rctr           = ctr+                  , rLambdaLevel   = lambda+                  , rUsedKinds     = usedKinds+                  , rUsedLbls      = usedLbls+                  , rinps          = inps+                  , rlambdaInps    = lambdaInps+                  , routs          = outs+                  , rtblMap        = tables+                  , spgm           = pgm+                  , rconstMap      = cmap+                  , rArrayMap      = arrays+                  , rexprMap       = emap+                  , rUserFuncs     = userFuncs+                  , rUIMap         = uis+                  , rCgMap         = cgs+                  , rDefns         = defns+                  , rSVCache       = swCache+                  , rAICache       = aiCache+                  , rConstraints   = cstrs+                  , rPartitionVars = pvs+                  , rSMTOptions    = smtOpts+                  , rOptGoals      = optGoals+                  , rAsserts       = asserts+                  , rQueryState    = qstate+                  , parentState    = Nothing                   }  -- | Generalization of 'Data.SBV.runSymbolic'@@ -1841,6 +1929,26 @@    st <- mkNewState cfg currentRunMode    runSymbolicInState st comp +-- | Catch the catastrophic case of context mismatch+contextMismatchError :: SBVContext -> SBVContext -> Maybe (Int, Int) -> Maybe (Int, Int) -> a+contextMismatchError ctx1 ctx2 level1 level2 = error $ unlines $ prefix ++ rest+  where prefix | ctx1 /= ctx2 = [ "Data.SBV: Mismatched contexts detected."+                                , "***"+                                , "*** Current context: " ++ show ctx1+                                , "*** Mixed with     : " ++ show ctx2+                                ]+               | True         = [ "Data.SBV: Mismatched levels detected in the same context."+                                , "***"+                                , "*** Refers to: " ++ show level1+                                , "*** And also : " ++ show level2+                                ]+        rest = [ "***"+               , "*** This happens if you call a proof-function (prove/sat/runSMT/isSatisfiable) etc."+               , "*** while another one is in execution, or use results from one such call in another."+               , "*** Please avoid such nested calls, all interactions should be from the same context."+               , "*** See https://github.com/LeventErkok/sbv/issues/71 for several examples."+               ]+ -- | Run a symbolic computation in a given state runSymbolicInState :: MonadIO m => State -> SymbolicT m a -> m (a, Result) runSymbolicInState st (SymbolicT c) = do@@ -1849,6 +1957,14 @@    r <- runReaderT c st    res <- liftIO $ extractSymbolicSimulationState st +   -- Check that the state wasn't clobbered in any way+   let check ctx | ctx == sbvContext st || ctx == globalSBVContext+                 = pure ()+                 | True+                 = contextMismatchError (sbvContext st) ctx Nothing Nothing++   mapM_ check $ nub $ G.universeBi res+    -- Clean-up after ourselves    qs <- liftIO $ readIORef $ rQueryState st    case qs of@@ -1911,7 +2027,7 @@    ds    <- reverse <$> readIORef defns    unint <- do unints <- Map.toList <$> readIORef uis                -- drop those that has a definition associated with it-               let defineds = mapMaybe smtDefGivenName ds+               let defineds = mapMaybe (smtDefGivenName . fst) ds                pure [ui | ui@(nm, _) <- unints, nm `notElem` defineds]    knds  <- readIORef usedKinds    cgMap <- Map.toList <$> readIORef cgs@@ -2022,12 +2138,15 @@ uncache :: Cached SV -> State -> IO SV uncache = uncacheGen rSVCache --- | An SMT array index is simply an int value-newtype ArrayIndex = ArrayIndex { unArrayIndex :: Int } deriving (Eq, Ord, G.Data)+-- | An SMT array index is simply an int value, and the context this array was created in+data ArrayIndex = ArrayIndex { unArrayIndex   :: Int+                             , unArrayContext :: SBVContext+                             }+               deriving (Eq, Ord, G.Data)  -- | We simply show indexes as the underlying integer instance Show ArrayIndex where-  show (ArrayIndex i) = show i+  show = show . unArrayIndex  -- | Uncache, retrieving SMT array indexes uncacheAI :: Cached ArrayIndex -> State -> IO ArrayIndex@@ -2056,14 +2175,15 @@ smtLibVersionExtension :: SMTLibVersion -> String smtLibVersionExtension SMTLib2 = "smt2" --- | Representation of an SMT-Lib program. In between pre and post goes the refuted models-data SMTLibPgm = SMTLibPgm SMTLibVersion [String]+-- | Representation of an SMT-Lib program. The second [String] are the function definitions,+-- which is *replicated* in the first one. There are cases where that we need the second part on its own.+data SMTLibPgm = SMTLibPgm SMTLibVersion [String] [String] -instance NFData SMTLibVersion where rnf a               = a `seq` ()-instance NFData SMTLibPgm     where rnf (SMTLibPgm v p) = rnf v `seq` rnf p+instance NFData SMTLibVersion where rnf a                 = a `seq` ()+instance NFData SMTLibPgm     where rnf (SMTLibPgm v p d) = rnf v `seq` rnf p `seq` rnf d  instance Show SMTLibPgm where-  show (SMTLibPgm _ pre) = intercalate "\n" pre+  show (SMTLibPgm _ pgm _) = intercalate "\n" pgm  -- Other Technicalities.. instance NFData CV where@@ -2201,13 +2321,13 @@  -- | A model, as returned by a solver data SMTModel = SMTModel {-       modelObjectives :: [(String, GeneralizedCV)]                               -- ^ Mapping of symbolic values to objective values.-     , modelBindings   :: Maybe [(NamedSymVar, CV)]                               -- ^ Mapping of input variables as reported by the solver. Only collected if model validation is requested.-     , modelAssocs     :: [(String, CV)]                                          -- ^ Mapping of symbolic values to constants.-     , modelUIFuns     :: [(String, (SBVType, Either String ([([CV], CV)], CV)))] -- ^ Mapping of uninterpreted functions to association lists in the model.-                                                                                  -- Note that an uninterpreted constant (function of arity 0) will be stored-                                                                                  -- in the 'modelAssocs' field. Left is used when the function returned is too-                                                                                  -- difficult for SBV to figure out what it means+       modelObjectives :: [(String, GeneralizedCV)]                                     -- ^ Mapping of symbolic values to objective values.+     , modelBindings   :: Maybe [(NamedSymVar, CV)]                                     -- ^ Mapping of input variables as reported by the solver. Only collected if model validation is requested.+     , modelAssocs     :: [(String, CV)]                                                -- ^ Mapping of symbolic values to constants.+     , modelUIFuns     :: [(String, (Bool, SBVType, Either String ([([CV], CV)], CV)))] -- ^ Mapping of uninterpreted functions to association lists in the model.+                                                                                        -- Note that an uninterpreted constant (function of arity 0) will be stored+                                                                                        -- in the 'modelAssocs' field. Left is used when the function returned is too+                                                                                        -- difficult for SBV to figure out what it means      }      deriving Show @@ -2247,6 +2367,7 @@             | MathSAT             | Yices             | Z3+            | OpenSMT             deriving (Show, Enum, Bounded)  -- | An SMT solver
Data/SBV/Internals.hs view
@@ -151,7 +151,7 @@ -- | 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+-- >>> prove  $ \x -> let d :: SFPHalf = sComparableSWordAsSFloatingPoint x in fpIsNaN d .|| fpIsNegativeZero d .|| sFloatingPointAsComparableSWord d .== x -- Q.E.D. -- >>> prove $ \x -> fpIsNegativeZero x .|| sComparableSWordAsSFloatingPoint (sFloatingPointAsComparableSWord x) `fpIsEqualObject` (x :: SFPHalf) -- Q.E.D.
Data/SBV/Lambda.hs view
@@ -41,7 +41,6 @@  import qualified Data.Foldable      as F import qualified Data.Map.Strict    as M-import qualified Data.IntMap.Strict as IM  import qualified Data.Generics.Uniplate.Data as G @@ -71,44 +70,46 @@         -- don't really impact anything.         comp State {                    -- These are not IORefs; so we share by copying  the value; changes won't be copied back-                     pathCond     = share pathCond-                   , startTime    = share startTime+                     sbvContext     = share sbvContext+                   , pathCond       = share pathCond+                   , startTime      = share startTime                     -- These are shared IORef's; and is shared, so they will be copied back to the parent state-                   , rProgInfo    = share rProgInfo-                   , rIncState    = share rIncState-                   , rCInfo       = share rCInfo-                   , rUsedKinds   = share rUsedKinds-                   , rUsedLbls    = share rUsedLbls-                   , rtblMap      = share rtblMap-                   , rArrayMap    = share rArrayMap-                   , rAICache     = share rAICache-                   , rUIMap       = share rUIMap-                   , rUserFuncs   = share rUserFuncs-                   , rCgMap       = share rCgMap-                   , rDefns       = share rDefns-                   , rSMTOptions  = share rSMTOptions-                   , rOptGoals    = share rOptGoals-                   , rAsserts     = share rAsserts+                   , rProgInfo      = share rProgInfo+                   , rIncState      = share rIncState+                   , rCInfo         = share rCInfo+                   , rUsedKinds     = share rUsedKinds+                   , rUsedLbls      = share rUsedLbls+                   , rUIMap         = share rUIMap+                   , rUserFuncs     = share rUserFuncs+                   , rCgMap         = share rCgMap+                   , rDefns         = share rDefns+                   , rSMTOptions    = share rSMTOptions+                   , rOptGoals      = share rOptGoals+                   , rAsserts       = share rAsserts+                   , rPartitionVars = share rPartitionVars                     -- Everything else is fresh in the substate; i.e., will not copy back-                   , stCfg        = fresh stCfg-                   , runMode      = fresh runMode-                   , rctr         = fresh rctr-                   , rLambdaLevel = fresh rLambdaLevel-                   , rinps        = fresh rinps-                   , rlambdaInps  = fresh rlambdaInps-                   , rConstraints = fresh rConstraints-                   , rObservables = fresh rObservables-                   , routs        = fresh routs-                   , spgm         = fresh spgm-                   , rconstMap    = fresh rconstMap-                   , rexprMap     = fresh rexprMap-                   , rSVCache     = fresh rSVCache-                   , rQueryState  = fresh rQueryState+                   , stCfg          = fresh stCfg+                   , runMode        = fresh runMode+                   , rctr           = fresh rctr+                   , rLambdaLevel   = fresh rLambdaLevel+                   , rtblMap        = fresh rtblMap+                   , rArrayMap      = fresh rArrayMap+                   , rAICache       = fresh rAICache+                   , rinps          = fresh rinps+                   , rlambdaInps    = fresh rlambdaInps+                   , rConstraints   = fresh rConstraints+                   , rObservables   = fresh rObservables+                   , routs          = fresh routs+                   , spgm           = fresh spgm+                   , rconstMap      = fresh rconstMap+                   , rexprMap       = fresh rexprMap+                   , rSVCache       = fresh rSVCache+                   , rQueryState    = fresh rQueryState                     -- keep track of our parent-                   , parentState  = Just inState+                   , parentState    = Just inState                    }  -- In this case, we expect just one group of parameters, with universal quantification@@ -148,9 +149,12 @@    where mkDef (Defn frees params body) = SMTDef nm fk frees (extractAllUniversals <$> params) body  -- | Create a named SMTLib function, in the given state, string version-namedLambdaStr :: (MonadIO m, Lambda (SymbolicT m) a) => State -> String -> Kind -> a -> m String-namedLambdaStr inState nm fk = namedLambdaGen mkDef inState fk-   where mkDef (Defn frees params body) = concat $ declUserFuns [SMTDef nm fk frees (extractAllUniversals <$> params) body]+namedLambdaStr :: (MonadIO m, Lambda (SymbolicT m) a) => State -> String -> SBVType -> a -> m String+namedLambdaStr inState nm t = namedLambdaGen mkDef inState fk+   where mkDef (Defn frees params body) = concat $ declUserFuns [(SMTDef nm fk frees (extractAllUniversals <$> params) body, t)]+         fk = case t of+                SBVType [] -> error $ "namedLambdaStr: Invalid type for " ++ show nm ++ ", empty!"+                SBVType xs -> last xs  -- | Generic constraint generator. constraintGen :: (MonadIO m, Constraint (SymbolicT m) a) => ([String] -> (Int -> String) -> b) -> State -> a -> m b@@ -215,11 +219,12 @@                    is            -- Inputs -                  ( _allConsts  -- This contains the CV->SV map, which isn't needed for lambdas since we don't support tables+                  ( _allConsts  -- Not needed, consts are sufficient for this translation                   , consts      -- constants used                   ) -                  _tbls         -- Tables                : nothing to do with them+                  tbls          -- Tables+                   _arrs         -- Arrays                : nothing to do with them                   _uis          -- Uninterpeted constants: nothing to do with them                   _axs          -- Axioms definitions    : nothing to do with them@@ -267,13 +272,38 @@                        paramList ps = '(' : unwords (map (\p -> '(' : show p ++ " " ++ smtType (kindOf p) ++ ")")  ps) ++ ")"                 body tabAmnt-                 | Just e <- simpleBody bindings out-                 = [replicate tabAmnt ' ' ++ e]+                 | null constTables+                 , null nonConstTables+                 , Just e <- simpleBody (constBindings ++ svBindings) out+                 = [tab ++ e]                  | True-                 = let tab = replicate tabAmnt ' '-                   in    [tab ++ "(let ((" ++ show s ++ " " ++ v ++ "))" | (s, v) <- bindings]-                      ++ [tab ++ show out ++ replicate (length bindings) ')']+                 = map (tab ++) $   [mkLet sv  | sv <- constBindings]+                                 ++ [mkTable t | t  <- constTables]+                                 ++ walk svBindings nonConstTables+                                 ++ [show out ++ replicate totalClose ')'] +                 where tab          = replicate tabAmnt ' '+                       mkBind l r   = "(let ((" ++ l ++ " " ++ r ++ "))"+                       mkLet (s, v) = mkBind (show s) v++                       mkTable (((i, ak, rk), elts), _) = mkBind nm (lambdaTable (map (const ' ') nm) ak rk elts)+                          where nm = "table" ++ show i++                       totalClose = length constBindings+                                  + length svBindings+                                  + length constTables+                                  + length nonConstTables++                       walk []  []        = []+                       walk []  remaining = error $ "Data.SBV: Impossible: Ran out of bindings, but tables remain: " ++ show remaining+                       walk (cur@(SV _ nd, _) : rest)  remaining =  map (mkTable . snd) ready+                                                                 ++ [mkLet cur]+                                                                 ++ walk rest notReady+                          where (ready, notReady) = partition (\(need, _) -> need < getLLI nd) remaining++               getLLI :: NodeId -> (Int, Int)+               getLLI (NodeId (_, l, i)) = (l, i)+                -- if we have just one definition returning it, simplify                simpleBody :: [(SV, String)] -> SV -> Maybe String                simpleBody [(v, e)] o | v == o = Just e@@ -283,8 +313,9 @@                 constants = filter ((`notElem` [falseSV, trueSV]) . fst) consts -               bindings :: [(SV, String)]-               bindings = map mkConst constants ++ map mkAsgn assignments+               constBindings, svBindings :: [(SV, String)]+               constBindings = map mkConst constants+               svBindings    = map mkAsgn assignments                 mkConst :: (SV, CV) -> (SV, String)                mkConst (sv, cv) = (sv, cvToSMTLib (roundingMode cfg) cv)@@ -296,11 +327,41 @@                                   , "   Saw: " ++ show outputs                                   ] +               rm = roundingMode cfg++               -- NB. The following is dead-code, since we ensure tbls is empty+               -- We used to support this, but there are issues, so dropping support+               -- See, for instance, https://github.com/LeventErkok/sbv/issues/664+               (tableMap, constTables, nonConstTablesUnindexed) = constructTables rm consts tbls++               -- Index each non-const table with the largest index of SV it needs+               nonConstTables = [ (maximum ((0, 0) : [getLLI n | SV _ n <- elts]), nct)+                                | nct@((_, elts), _) <- nonConstTablesUnindexed]++               lambdaTable :: String -> Kind -> Kind -> [SV] -> String+               lambdaTable extraSpace ak rk elts = "(lambda ((" ++ lv ++ " " ++ smtType ak ++ "))" ++ space ++ chain 0 elts ++ ")"+                 where cnst k i = cvtCV rm (mkConstCV k (i::Integer))++                       lv = "idx"++                       -- If more than 5 elts, use new-lines+                       long = not (null (drop 5 elts))+                       space+                         | long+                         = "\n                  " ++ extraSpace+                         | True+                         = " "++                       chain _ []     = cnst rk 0+                       chain _ [x]    = show x+                       chain i (x:xs) = "(ite (= " ++ lv ++ " " ++ cnst ak i ++ ") "+                                           ++ show x ++ space+                                           ++ chain (i+1) xs+                                           ++ ")"+                mkAsgn (sv, e) = (sv, converter e)                converter = cvtExp curProgInfo solverCaps rm tableMap funcMap                  where solverCaps = capabilities (solver cfg)-                       rm         = roundingMode cfg-                       tableMap   = IM.empty                        funcMap    = M.empty  {- HLint ignore module "Use second" -}
Data/SBV/List.hs view
@@ -148,7 +148,7 @@ -- Q.E.D. -- >>> sat $ \(l :: SList Word16) -> length l .>= 2 .&& listToListAt l 0 ./= listToListAt l (length l - 1) -- Satisfiable. Model:---   s0 = [0,16] :: [Word16]+--   s0 = [0,64] :: [Word16] listToListAt :: SymVal a => SList a -> SInteger -> SList a listToListAt s offset = subList s offset 1 @@ -157,9 +157,6 @@ -- -- >>> prove $ \i -> i `inRange` (0, 4) .=> [1,1,1,1,1] `elemAt` i .== (1::SInteger) -- Q.E.D.------ ->>> prove $ \(l :: SList Integer) i e -> i `inRange` (0, length l - 1) .&& l `elemAt` i .== e .=> indexOf l (singleton e) .<= i--- Q.E.D. elemAt :: SymVal a => SList a -> SInteger -> SBV a elemAt l i   | Just xs <- unliteral l, Just ci <- unliteral i, ci >= 0, ci < genericLength xs, let x = xs `genericIndex` ci@@ -329,9 +326,6 @@  -- | @`indexOf` l sub@. Retrieves first position of @sub@ in @l@, @-1@ if there are no occurrences. -- Equivalent to @`offsetIndexOf` l sub 0@.------ ->>> prove $ \(l :: SList Int8) i -> i .> 0 .&& i .< length l .=> indexOf l (subList l i 1) .<= i--- Q.E.D. -- -- >>> prove $ \(l1 :: SList Word16) l2 -> length l2 .> length l1 .=> indexOf l1 l2 .== -1 -- Q.E.D.
Data/SBV/Provers/Bitwuzla.hs view
@@ -24,7 +24,7 @@            name         = Bitwuzla          , executable   = "bitwuzla"          , preprocess   = id-         , options      = const ["--smt2", "-m", "--output-format=smt2", "--no-exit-codes", "--incremental"]+         , options      = const ["--produce-models"]          , engine       = standardEngine "SBV_BITWUZLA" "SBV_BITWUZLA_OPTIONS"          , capabilities = SolverCapabilities {                                 supportsQuantifiers        = False
+ Data/SBV/Provers/OpenSMT.hs view
@@ -0,0 +1,55 @@+-----------------------------------------------------------------------------+-- |+-- Module    : Data.SBV.Provers.OpenSMT+-- Copyright : (c) Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- The connection to the OpenSMT SMT solver+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror #-}++module Data.SBV.Provers.OpenSMT(openSMT) where++import Data.SBV.Core.Data+import Data.SBV.SMT.SMT++-- | The description of the OpenSMT SMT solver.+-- The default executable is @\"opensmt\"@, which must be in your path. You can use the @SBV_OpenSMT@ environment variable to point to the executable on your system.+-- You can use the @SBV_OpenSMT_OPTIONS@ environment variable to override the options.+openSMT :: SMTSolver+openSMT = SMTSolver {+           name         = OpenSMT+         , executable   = "openSMT"+         , preprocess   = id+         , options      = modConfig []+         , engine       = standardEngine "SBV_OpenSMT" "SBV_OpenSMT_OPTIONS"+         , capabilities = SolverCapabilities {+                                supportsQuantifiers        = False+                              , supportsDefineFun          = True+                              , supportsDistinct           = True+                              , supportsBitVectors         = False+                              , supportsUninterpretedSorts = True+                              , supportsUnboundedInts      = True+                              , supportsInt2bv             = False+                              , supportsReals              = True+                              , supportsApproxReals        = False+                              , supportsDeltaSat           = Nothing+                              , supportsIEEE754            = False+                              , supportsSets               = False+                              , supportsOptimization       = False+                              , supportsPseudoBooleans     = False+                              , supportsCustomQueries      = True+                              , supportsGlobalDecls        = True+                              , supportsDataTypes          = False+                              , supportsFoldAndMap         = False+                              , supportsSpecialRels        = False+                              , supportsDirectAccessors    = False+                              , supportsFlattenedModels    = Nothing+                              }+         }++ where modConfig :: [String] -> SMTConfig -> [String]+       modConfig opts _cfg = opts
Data/SBV/Provers/Prover.hs view
@@ -24,13 +24,13 @@ module Data.SBV.Provers.Prover (          SMTSolver(..), SMTConfig(..), Predicate        , ProvableM(..), Provable, SatisfiableM(..), Satisfiable-       , generateSMTBenchmarkSat, generateSMTBenchmarkProof, ConstraintSet+       , generateSMTBenchmarkSat, generateSMTBenchmarkProof, defs2smt, ConstraintSet        , ThmResult(..), SatResult(..), AllSatResult(..), SafeResult(..), OptimizeResult(..), SMTResult(..)        , SExecutable(..), isSafe        , runSMT, runSMTWith        , SatModel(..), Modelable(..), displayModels, extractModels        , getModelDictionaries, getModelValues, getModelUninterpretedValues-       , abc, boolector, bitwuzla, cvc4, cvc5, dReal, mathSAT, yices, z3, defaultSMTCfg, defaultDeltaSMTCfg+       , abc, boolector, bitwuzla, cvc4, cvc5, dReal, mathSAT, yices, z3, openSMT, defaultSMTCfg, defaultDeltaSMTCfg        , proveWithAny, proveWithAll, proveConcurrentWithAny, proveConcurrentWithAll        , satWithAny,   satWithAll,   satConcurrentWithAny,   satConcurrentWithAll        ) where@@ -77,6 +77,7 @@ import qualified Data.SBV.Provers.MathSAT   as MathSAT import qualified Data.SBV.Provers.Yices     as Yices import qualified Data.SBV.Provers.Z3        as Z3+import qualified Data.SBV.Provers.OpenSMT   as OpenSMT  import GHC.TypeLits @@ -148,6 +149,12 @@                             , allOnStdOut                             ] +-- | Default configuration for the OpenSMT SMT solver+openSMT :: SMTConfig+openSMT = mkConfig OpenSMT.openSMT SMTLib2 [ Control.OptionKeyword ":smtlib2_compliant" ["true"]+                                           , allOnStdOut+                                           ]+ -- | The default solver used by SBV. This is currently set to z3. defaultSMTCfg :: SMTConfig defaultSMTCfg = z3@@ -478,13 +485,20 @@                             notConcrete sv = wrap ("Data.SBV: Cannot validate the model, since " ++ show sv ++ " is not concretely computable.")                                                  (  perhaps (why sv)-                                                 ++ [ "SBV's model validator is incomplete, and cannot handle this particular case."-                                                    , "Please report this as a feature request or possibly a bug!"-                                                    ]                                                  )-                                where perhaps Nothing  = []-                                      perhaps (Just x) = [x, ""]+                                where perhaps Nothing  = case resObservables result of+                                                           [] -> []+                                                           xs -> [ "There are observable values in the model: " ++ unwords [show n | (n, _, _) <- xs]+                                                                 , "SBV cannot validate in the presence of observables, unfortunately."+                                                                 , "Try validation after removing calls to 'observe'."+                                                                 ] +                                      perhaps (Just x) = [ x+                                                         , ""+                                                         , "SBV's model validator is incomplete, and cannot handle this particular case."+                                                         , "Please report this as a feature request or possibly a bug!"+                                                         ]+                                       -- This is incomplete, but should capture the most common cases                                       why s = case s `lookup` S.toList (pgmAssignments (resAsgns result)) of                                                 Nothing            -> Nothing@@ -559,17 +573,22 @@                         walkConstraints cstrs (checkOutputs (resOutputs result)) +-- | Given a satisfiability problem, extract the function definitions in it+defs2smt :: SatisfiableM m a => a -> m String+defs2smt = generateSMTBenchMarkGen True satArgReduce defs+  where defs (SMTLibPgm _ _ ds) = intercalate "\n" ds+ -- | Create an SMT-Lib2 benchmark, for a SAT query. generateSMTBenchmarkSat :: SatisfiableM m a => a -> m String-generateSMTBenchmarkSat = generateSMTBenchMarkGen True satArgReduce+generateSMTBenchmarkSat = generateSMTBenchMarkGen True satArgReduce (\p -> show p ++ "\n(check-sat)\n")  -- | Create an SMT-Lib2 benchmark, for a Proof query. generateSMTBenchmarkProof :: ProvableM m a => a -> m String-generateSMTBenchmarkProof = generateSMTBenchMarkGen False proofArgReduce+generateSMTBenchmarkProof = generateSMTBenchMarkGen False proofArgReduce (\p -> show p ++ "\n(check-sat)\n")  -- | Generic benchmark creator-generateSMTBenchMarkGen :: MonadIO m => Bool -> (a -> SymbolicT m SBool) -> a -> m String-generateSMTBenchMarkGen isSat reduce a = do+generateSMTBenchMarkGen :: MonadIO m => Bool -> (a -> SymbolicT m SBool) -> (SMTLibPgm -> b) -> a -> m b+generateSMTBenchMarkGen isSat reduce render a = do       t <- liftIO getZonedTime        let comments = ["Automatically created by SBV on " ++ show t]@@ -578,9 +597,8 @@       (_, res) <- runSymbolic cfg (SMTMode QueryInternal ISetup isSat cfg) $ reduce a >>= output        let SMTProblem{smtLibPgm} = Control.runProofOn (SMTMode QueryInternal IRun isSat cfg) QueryInternal comments res-          out                   = show (smtLibPgm cfg) -      return $ out ++ "\n(check-sat)\n"+      return $ render (smtLibPgm cfg)  checkNoOptimizations :: MonadIO m => QueryT m () checkNoOptimizations = do objectives <- Control.getObjectives@@ -648,59 +666,94 @@  -- Functions instance (SymVal a, SatisfiableM m p) => SatisfiableM m (SBV a -> p) where-  satArgReduce k = mkArg >>= \a -> satArgReduce $ k a+  satArgReduce fn = mkArg >>= \a -> satArgReduce $ fn a  instance (SymVal a, ProvableM m p) => ProvableM m (SBV a -> p) where-  proofArgReduce k = mkArg >>= \a -> proofArgReduce $ k a+  proofArgReduce fn = mkArg >>= \a -> proofArgReduce $ fn a  -- Arrays instance (HasKind a, HasKind b, SatisfiableM m p) => SatisfiableM m (SArray a b -> p) where-  satArgReduce k = newArray_ Nothing >>= \a -> satArgReduce $ k a+  satArgReduce fn = newArray_ Nothing >>= \a -> satArgReduce $ fn a  instance (HasKind a, HasKind b, ProvableM m p) => ProvableM m (SArray a b -> p) where-  proofArgReduce k = newArray_ Nothing >>= \a -> proofArgReduce $ k a+  proofArgReduce fn = newArray_ Nothing >>= \a -> proofArgReduce $ fn a  -- 2 Tuple instance (SymVal a, SymVal b, SatisfiableM m p) => SatisfiableM m ((SBV a, SBV b) -> p) where-  satArgReduce k = mkArg >>= \a -> satArgReduce $ \b -> k (a, b)+  satArgReduce fn = mkArg >>= \a -> satArgReduce $ \b -> fn (a, b)  instance (SymVal a, SymVal b, ProvableM m p) => ProvableM m ((SBV a, SBV b) -> p) where-  proofArgReduce k = mkArg >>= \a -> proofArgReduce $ \b -> k (a, b)+  proofArgReduce fn = mkArg >>= \a -> proofArgReduce $ \b -> fn (a, b)  -- 3 Tuple instance (SymVal a, SymVal b, SymVal c, SatisfiableM m p) => SatisfiableM m ((SBV a, SBV b, SBV c) -> p) where-  satArgReduce k = mkArg >>= \a -> satArgReduce $ \b c -> k (a, b, c)+  satArgReduce fn = mkArg >>= \a -> satArgReduce $ \b c -> fn (a, b, c)  instance (SymVal a, SymVal b, SymVal c, ProvableM m p) => ProvableM m ((SBV a, SBV b, SBV c) -> p) where-  proofArgReduce k = mkArg >>= \a -> proofArgReduce $ \b c -> k (a, b, c)+  proofArgReduce fn = mkArg >>= \a -> proofArgReduce $ \b c -> fn (a, b, c)  -- 4 Tuple instance (SymVal a, SymVal b, SymVal c, SymVal d, SatisfiableM m p) => SatisfiableM m ((SBV a, SBV b, SBV c, SBV d) -> p) where-  satArgReduce k = mkArg  >>= \a -> satArgReduce $ \b c d -> k (a, b, c, d)+  satArgReduce fn = mkArg  >>= \a -> satArgReduce $ \b c d -> fn (a, b, c, d)  instance (SymVal a, SymVal b, SymVal c, SymVal d, ProvableM m p) => ProvableM m ((SBV a, SBV b, SBV c, SBV d) -> p) where-  proofArgReduce k = mkArg  >>= \a -> proofArgReduce $ \b c d -> k (a, b, c, d)+  proofArgReduce fn = mkArg  >>= \a -> proofArgReduce $ \b c d -> fn (a, b, c, d)  -- 5 Tuple instance (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, SatisfiableM m p) => SatisfiableM m ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) where-  satArgReduce k = mkArg >>= \a -> satArgReduce $ \b c d e -> k (a, b, c, d, e)+  satArgReduce fn = mkArg >>= \a -> satArgReduce $ \b c d e -> fn (a, b, c, d, e)  instance (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, ProvableM m p) => ProvableM m ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) where-  proofArgReduce k = mkArg >>= \a -> proofArgReduce $ \b c d e -> k (a, b, c, d, e)+  proofArgReduce fn = mkArg >>= \a -> proofArgReduce $ \b c d e -> fn (a, b, c, d, e)  -- 6 Tuple instance (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, SymVal f, SatisfiableM m p) => SatisfiableM m ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) where-  satArgReduce k = mkArg >>= \a -> satArgReduce $ \b c d e f -> k (a, b, c, d, e, f)+  satArgReduce fn = mkArg >>= \a -> satArgReduce $ \b c d e f -> fn (a, b, c, d, e, f)  instance (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, SymVal f, ProvableM m p) => ProvableM m ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) where-  proofArgReduce k = mkArg >>= \a -> proofArgReduce $ \b c d e f -> k (a, b, c, d, e, f)+  proofArgReduce fn = mkArg >>= \a -> proofArgReduce $ \b c d e f -> fn (a, b, c, d, e, f)  -- 7 Tuple instance (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, SymVal f, SymVal g, SatisfiableM m p) => SatisfiableM m ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) where-  satArgReduce k = mkArg >>= \a -> satArgReduce $ \b c d e f g -> k (a, b, c, d, e, f, g)+  satArgReduce fn = mkArg >>= \a -> satArgReduce $ \b c d e f g -> fn (a, b, c, d, e, f, g)  instance (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, SymVal f, SymVal g, ProvableM m p) => ProvableM m ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) where-  proofArgReduce k = mkArg >>= \a -> proofArgReduce $ \b c d e f g -> k (a, b, c, d, e, f, g)+  proofArgReduce fn = mkArg >>= \a -> proofArgReduce $ \b c d e f g -> fn (a, b, c, d, e, f, g)++-- 8 Tuple+instance (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, SymVal f, SymVal g, SymVal h, SatisfiableM m p) => SatisfiableM m ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h) -> p) where+  satArgReduce fn = mkArg >>= \a -> satArgReduce $ \b c d e f g h -> fn (a, b, c, d, e, f, g, h)++instance (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, SymVal f, SymVal g, SymVal h, ProvableM m p) => ProvableM m ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h) -> p) where+  proofArgReduce fn = mkArg >>= \a -> proofArgReduce $ \b c d e f g h -> fn (a, b, c, d, e, f, g, h)++-- 9 Tuple+instance (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, SymVal f, SymVal g, SymVal h, SymVal i, SatisfiableM m p) => SatisfiableM m ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i) -> p) where+  satArgReduce fn = mkArg >>= \a -> satArgReduce $ \b c d e f g h i -> fn (a, b, c, d, e, f, g, h, i)++instance (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, SymVal f, SymVal g, SymVal h, SymVal i, ProvableM m p) => ProvableM m ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i) -> p) where+  proofArgReduce fn = mkArg >>= \a -> proofArgReduce $ \b c d e f g h i -> fn (a, b, c, d, e, f, g, h, i)++-- 10 Tuple+instance (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, SymVal f, SymVal g, SymVal h, SymVal i, SymVal j, SatisfiableM m p) => SatisfiableM m ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j) -> p) where+  satArgReduce fn = mkArg >>= \a -> satArgReduce $ \b c d e f g h i j -> fn (a, b, c, d, e, f, g, h, i, j)++instance (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, SymVal f, SymVal g, SymVal h, SymVal i, SymVal j, ProvableM m p) => ProvableM m ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j) -> p) where+  proofArgReduce fn = mkArg >>= \a -> proofArgReduce $ \b c d e f g h i j -> fn (a, b, c, d, e, f, g, h, i, j)++-- 11 Tuple+instance (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, SymVal f, SymVal g, SymVal h, SymVal i, SymVal j, SymVal k, SatisfiableM m p) => SatisfiableM m ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k) -> p) where+  satArgReduce fn = mkArg >>= \a -> satArgReduce $ \b c d e f g h i j k -> fn (a, b, c, d, e, f, g, h, i, j, k)++instance (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, SymVal f, SymVal g, SymVal h, SymVal i, SymVal j, SymVal k, ProvableM m p) => ProvableM m ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k) -> p) where+  proofArgReduce fn = mkArg >>= \a -> proofArgReduce $ \b c d e f g h i j k -> fn (a, b, c, d, e, f, g, h, i, j, k)++-- 12 Tuple+instance (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, SymVal f, SymVal g, SymVal h, SymVal i, SymVal j, SymVal k, SymVal l, SatisfiableM m p) => SatisfiableM m ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k, SBV l) -> p) where+  satArgReduce fn = mkArg >>= \a -> satArgReduce $ \b c d e f g h i j k l -> fn (a, b, c, d, e, f, g, h, i, j, k, l)++instance (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, SymVal f, SymVal g, SymVal h, SymVal i, SymVal j, SymVal k, SymVal l, ProvableM m p) => ProvableM m ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k, SBV l) -> p) where+  proofArgReduce fn = mkArg >>= \a -> proofArgReduce $ \b c d e f g h i j k l -> fn (a, b, c, d, e, f, g, h, i, j, k, l)  -- | Generalization of 'Data.SBV.runSMT' runSMT :: MonadIO m => SymbolicT m a -> m a
Data/SBV/Provers/Z3.hs view
@@ -6,7 +6,7 @@ -- Maintainer: erkokl@gmail.com -- Stability : experimental ----- The connection to the MathSAT SMT solver+-- The connection to the Z3 SMT solver -----------------------------------------------------------------------------  {-# LANGUAGE ScopedTypeVariables #-}
Data/SBV/RegExp.hs view
@@ -87,7 +87,7 @@ -- >>> let phone = pre * "-" * post -- >>> sat $ \s -> (s :: SString) `match` phone -- Satisfiable. Model:---   s0 = "200-8000" :: String+--   s0 = "800-8000" :: String class RegExpMatchable a where    -- | @`match` s r@ checks whether @s@ is in the language generated by @r@.    match :: a -> RegExp -> SBool
Data/SBV/SMT/SMT.hs view
@@ -417,10 +417,10 @@   getModelObjectiveValue v r = v `M.lookup` getModelObjectives r    -- | Extract model uninterpreted-functions-  getModelUIFuns :: a -> M.Map String (SBVType, Either String ([([CV], CV)], CV))+  getModelUIFuns :: a -> M.Map String (Bool, SBVType, Either String ([([CV], CV)], CV))    -- | Extract the value of an uninterpreted-function as an association list-  getModelUIFunValue :: String -> a -> Maybe (SBVType, Either String ([([CV], CV)], CV))+  getModelUIFunValue :: String -> a -> Maybe (Bool, SBVType, Either String ([([CV], CV)], CV))   getModelUIFunValue v r = v `M.lookup` getModelUIFuns r  -- | Return all the models from an 'Data.SBV.allSat' call, similar to 'extractModel' but@@ -581,27 +581,35 @@         lTrimRight = length . dropWhile isSpace . reverse  -- | Show an uninterpreted function-showModelUI :: SMTConfig -> (String, (SBVType, Either String ([([CV], CV)], CV))) -> String-showModelUI cfg (nm, (SBVType ts, interp))+showModelUI :: SMTConfig -> (String, (Bool, SBVType, Either String ([([CV], CV)], CV))) -> String+showModelUI cfg (nm, (isCurried, SBVType ts, interp))   = intercalate "\n" $ case interp of-                         Left  e  -> ["  " ++ l | l <- [sig,  e]]+                         Left  e  -> ["  " ++ l | l <- [sig, e]]                          Right ds -> ["  " ++ l | l <- sig : mkBody ds]   where noOfArgs = length ts - 1 -        sig      = nm ++ " :: " ++ intercalate " -> " (map showBaseKind ts)+        (ats, rt) = case map showBaseKind ts of+                     []  -> error $ "showModelUI: Unexpected type: " ++ show (SBVType ts)+                     tss -> (init tss, last tss) +        sig | isCurried = nm ++ " :: "  ++ intercalate " -> " ats ++  " -> " ++ rt+            | True      = nm ++ " :: (" ++ intercalate ", "   ats ++ ") -> " ++ rt+         mkBody (defs, dflt) = map align body           where ls       = map line defs-                defLine  = (nm : replicate noOfArgs "_", scv dflt)+                defLine  = (replicate noOfArgs "_", scv dflt)                 body     = ls ++ [defLine]                  colWidths = [maximum (0 : map length col) | col <- transpose (map fst body)]                  resWidth  = maximum  (0 : map (length . snd) body) -                align (xs, r) = unwords $ zipWith left colWidths xs ++ ["=", left resWidth r]+                align (xs, r) = nm ++ " " ++ merge (zipWith left colWidths xs) ++ " = " ++ left resWidth r                    where left i x = take i (x ++ repeat ' ') +                         merge as | isCurried = unwords as+                                  | True      = '(' : intercalate ", " as ++ ")"+         -- NB. We'll ignore crackNum here. Seems to be overkill while displaying an         -- uninterpreted function.         scv = sh (printBase cfg)@@ -617,12 +625,12 @@         -- we might want to do this properly later somehow. (Perhaps         -- using some sort of a view pattern.)         line :: ([CV], CV) -> ([String], String)-        line (args, r) = (nm : map (paren . scv) args, scv r)-          where -- If negative, parenthesize. I think this is the only case+        line (args, r) = (map (paren isCurried . scv) args, scv r)+          where -- If negative and if we're curried, parenthesize. I think this is the only case                 -- we need to worry about. Hopefully!-                paren :: String -> String-                paren x@('-':_) = '(' : x ++ ")"-                paren x         = x+                paren :: Bool -> String -> String+                paren True x@('-':_) = '(' : x ++ ")"+                paren _    x         = x  -- | Show a constant value, in the user-specified base shCV :: SMTConfig -> CV -> String@@ -743,7 +751,7 @@                                 return collated                        where safeGetLine isFirst h =-                                         let timeOutToUse | isSetCommand mbCommand = Just 1000000+                                         let timeOutToUse | isSetCommand mbCommand = Just 2000000                                                           | isFirst                = mbTimeOut                                                           | True                   = Just 5000000                                              timeOutMsg t | isFirst = "User specified timeout of " ++ showTimeoutValue t ++ " exceeded"
Data/SBV/SMT/SMTLib.hs view
@@ -36,10 +36,10 @@ -- | Convert to SMTLib-2 format toSMTLib2 :: SMTLibConverter SMTLibPgm toSMTLib2 = cvt SMTLib2-  where cvt v ctx progInfo kindInfo isSat comments qinps consts tbls arrs uis axs asgnsSeq cstrs out config = SMTLibPgm v pgm-         where converter = case v of-                             SMTLib2 -> SMT2.cvt-               pgm = converter ctx progInfo kindInfo isSat comments qinps consts tbls arrs uis axs asgnsSeq cstrs out config+  where cvt v ctx progInfo kindInfo isSat comments qinps consts tbls arrs uis axs asgnsSeq cstrs out config = SMTLibPgm v pgm defs+         where converter   = case v of+                               SMTLib2 -> SMT2.cvt+               (pgm, defs) = converter ctx progInfo kindInfo isSat comments qinps consts tbls arrs uis axs asgnsSeq cstrs out config  -- | Convert to SMTLib-2 format toIncSMTLib2 :: SMTLibIncConverter [String]
Data/SBV/SMT/SMTLib2.hs view
@@ -16,7 +16,7 @@  {-# OPTIONS_GHC -Wall -Werror #-} -module Data.SBV.SMT.SMTLib2(cvt, cvtExp, cvtInc, declUserFuns) where+module Data.SBV.SMT.SMTLib2(cvt, cvtExp, cvtCV, cvtInc, declUserFuns, constructTables) where  import Data.Bits  (bit) import Data.List  (intercalate, partition, nub, elemIndex)@@ -47,8 +47,8 @@ tbd e = error $ "SBV.SMTLib2: Not-yet-supported: " ++ e  -- | Translate a problem into an SMTLib2 script-cvt :: SMTLibConverter [String]-cvt ctx curProgInfo kindInfo isSat comments allInputs (allConsts, consts) tbls arrs uis defs (SBVPgm asgnsSeq) cstrs out cfg = pgm+cvt :: SMTLibConverter ([String], [String])+cvt ctx curProgInfo kindInfo isSat comments allInputs (allConsts, consts) tbls arrs uis defs (SBVPgm asgnsSeq) cstrs out cfg = (pgm, exportedDefs)   where hasInteger     = KUnbounded `Set.member` kindInfo         hasReal        = KReal      `Set.member` kindInfo         hasFP          =  not (null [() | KFP{} <- Set.toList kindInfo])@@ -66,6 +66,7 @@         hasArrayInits  = (not . null) $  [() | (_, (_, _, ArrayFree (Left  (Just _)))) <- arrs]                                       ++ [() | (_, (_, _, ArrayFree (Right _       ))) <- arrs]         hasOverflows   = (not . null) [() | (_ :: OvOp) <- G.universeBi asgnsSeq]+        hasQuantBools  = (not . null) [() | QuantifiedBool _ <- G.universeBi asgnsSeq]         hasList        = any isList kindInfo         hasSets        = any isSet kindInfo         hasTuples      = not . null $ tupleArities@@ -154,6 +155,7 @@            | hasRegExp             = setAll "has regular expressions"            | hasArrayInits         = setAll "has array initializers"            | hasOverflows          = setAll "has overflow checks"+           | hasQuantBools         = setAll "has quantified booleans"             | hasFP || hasRounding            = if needsQuantifiers@@ -237,7 +239,7 @@              ++ [ "; --- SBV Function definitions" | not (null funcMap) ]              ++ concat [ declSBVFunc op nm | (op, nm) <- M.toAscList funcMap ]              ++ [ "; --- user defined functions ---"]-             ++ declUserFuns defs+             ++ userDefs              ++ [ "; --- assignments ---" ]              ++ concatMap (declDef curProgInfo cfg tableMap funcMap) asgns              ++ [ "; --- arrayDelayeds ---" ]@@ -249,10 +251,16 @@              ++ [ "; --- formula ---" ]              ++ finalAssert -        allTables      = [(t, genTableData rm (map fst consts) t) | t <- tbls]-        constTables    = [(t, d) | (t, Left  d) <- allTables]-        nonConstTables = [(t, d) | (t, Right d) <- allTables]+        userDefs     = declUserFuns defs+        exportedDefs+          | null userDefs+          = ["; No calls to 'smtFunction' found."]+          | True+          = "; Automatically generated by SBV. Do not modify!" : userDefs ++        (tableMap, constTables, nonConstTables) = constructTables rm consts tbls+         (arrayConstants, arrayDelayeds, arraySetups) = unzip3 $ map (declArray cfg allConsts) arrs         delayedEqualities = concatMap snd nonConstTables @@ -291,9 +299,6 @@                   | s == falseSV = Just $ Left falseSV                   | True         = Just $ Left s -        tableMap  = IM.fromList $ map grab allTables-          where grab (((t, _, _), _), _) = (t, "table" ++ show t)-         -- SBV only functions.         funcMap = M.fromList reverses           where reverses = zip (nub [op | op@(SeqOp SBVReverse{}) <- G.universeBi asgnsSeq])@@ -501,11 +506,10 @@          (arrayConstants, arrayDelayeds, arraySetups) = unzip3 $ map (declArray cfg allConsts) arrs -        allTables = [(t, either id id (genTableData rm (map fst consts) t)) | t <- tbls]-        (tableDecls, tableAssigns) = unzip $ map mkTable allTables+        (tableMap, allTables) = (tm, ct ++ nct)+            where (tm, ct, nct) = constructTables rm consts tbls -        tableMap  = IM.fromList $ map mkIdx allTables-          where mkIdx (((t, _, _), _), _) = (t, "table" ++ show t)+        (tableDecls, tableAssigns) = unzip $ map mkTable allTables          -- If we need flattening in models, do emit the required lines if preset         settings@@ -551,8 +555,8 @@          tk  = smtType ak          res = "(forall ((x " ++ tk ++ ") (y " ++ tk ++ ")) (= " ++ lhs ++ " " ++ rhs ++ "))" -declUI :: ProgInfo -> (String, (Maybe [String], SBVType)) -> [String]-declUI ProgInfo{progTransClosures} (i, (_, t)) = declareName i t Nothing ++ declClosure+declUI :: ProgInfo -> (String, (Bool, Maybe [String], SBVType)) -> [String]+declUI ProgInfo{progTransClosures} (i, (_, _, t)) = declareName i t Nothing ++ declClosure   where declClosure | Just external <- lookup i progTransClosures                     =  declareName external t Nothing                     ++ ["(assert " ++ mkRelEq external ("transitive-closure", i) (argKind t) ++ ")"]@@ -564,28 +568,28 @@  -- Note that even though we get all user defined-functions here (i.e., lambda and axiom), we can only have defined-functions -- and axioms. We spit axioms as is; and topologically sort the definitions.-declUserFuns :: [SMTDef] -> [String]+declUserFuns :: [(SMTDef, SBVType)] -> [String] declUserFuns ds   | not (null lambdas)   = error $ unlines $ "Data.SBV.declUserFuns: Unexpected anonymous functions in declDef:" : map show lambdas   | True   = declFuncs others-  where (lambdas, others) = partition isLam ds+  where (lambdas, others) = partition (isLam . fst) ds         isLam SMTLam{} = True         isLam SMTDef{} = False  -- We need to topologically sort the user given definitions and axioms and put them in the proper order and construct. -- Note that there are no anonymous functions at this level.-declFuncs :: [SMTDef] -> [String]+declFuncs :: [(SMTDef, SBVType)] -> [String] declFuncs ds = map declGroup sorted   where mkNode d = (d, getKey d, getDeps d) -        getKey d = case d of-                     SMTDef n _ _ _ _ -> n-                     SMTLam{}         -> error $ "Data.SBV.declFuns: Unexpected definition kind: " ++ show d+        getKey (d, _) = case d of+                         SMTDef n _ _ _ _ -> n+                         SMTLam{}         -> error $ "Data.SBV.declFuns: Unexpected definition kind: " ++ show d -        getDeps (SMTDef _ _ d _ _) = d-        getDeps l@SMTLam{}         = error $ "Data.SBV.declFuns: Unexpected definition kind: " ++ show l+        getDeps (SMTDef _ _ d _ _, _) = d+        getDeps (l@SMTLam{}, t)       = error $ "Data.SBV.declFuns: Unexpected definition: " ++ show (l, t)          mkDecl Nothing  rt = "() "    ++ rt         mkDecl (Just p) rt = p ++ " " ++ rt@@ -598,8 +602,8 @@                                          [x] -> declUserDef True x                                          xs  -> declUserDefMulti xs -        declUserDef _ d@SMTLam{} = error $ "Data.SBV.declFuns: Unexpected anonymous lambda in user-defined functions: " ++ show d-        declUserDef isRec (SMTDef nm fk deps param body) = ("; -- user given definition: " ++ nm ++ recursive ++ frees ++ "\n") ++ s+        declUserDef _ d@(SMTLam{}, _) = error $ "Data.SBV.declFuns: Unexpected anonymous lambda in user-defined functions: " ++ show d+        declUserDef isRec (SMTDef nm fk deps param body, ty) = ("; " ++ nm ++ " :: " ++ show ty ++ recursive ++ frees ++ "\n") ++ s            where (recursive, definer) | isRec = (" [Recursive]", "define-fun-rec")                                       | True  = ("",             "define-fun") @@ -613,12 +617,12 @@          -- declare a bunch of mutually-recursive functions         declUserDefMulti bs = render $ map collect bs-          where collect d@SMTLam{} = error $ "Data.SBV.declFuns: Unexpected lambda in user-defined mutual-recursion group: " ++ show d-                collect (SMTDef nm fk deps param body) = (deps, nm, '(' : nm ++ " " ++  decl ++ ")", body 3)+          where collect d@(SMTLam{}, _) = error $ "Data.SBV.declFuns: Unexpected lambda in user-defined mutual-recursion group: " ++ show d+                collect (SMTDef nm fk deps param body, ty) = (deps, nm, ty, '(' : nm ++ " " ++  decl ++ ")", body 3)                   where decl = mkDecl param (smtType fk)                  render defs = intercalate "\n" $-                                  [ "; -- user given mutually-recursive definitions: " ++ intercalate ", " [n | (_, n, _, _) <- defs]+                                  [ "; " ++ intercalate ", " [n ++ " :: " ++ show ty | (_, n, ty, _, _) <- defs]                                   , "(define-funs-rec"                                   ]                                ++ [ open i ++ param d ++ close1 i | (i, d) <- zip [1..] defs]@@ -626,10 +630,10 @@                      where open 1 = "  ("                            open _ = "   " -                           param (_, _, p, _) = p+                           param (_deps, _nm, _ty, p, _body) = p -                           dump (deps, nm, _, body) = "; Definition of: " ++ nm ++ ". [Refers to: " ++ intercalate ", " deps ++ "]"-                                                    ++ "\n" ++ body+                           dump (deps, nm, ty, _, body) = "; Definition of: " ++ nm ++ " :: " ++ show ty ++ ". [Refers to: " ++ intercalate ", " deps ++ "]"+                                                        ++ "\n" ++ body                             ld = length defs @@ -663,6 +667,19 @@   where t    = "table" ++ show i         decl = "(declare-fun " ++ t ++ " (" ++ smtType ak ++ ") " ++ smtType rk ++ ")" +constructTables :: RoundingMode -> [(SV, CV)] -> [((Int, Kind, Kind), [SV])]+                -> ( IM.IntMap String                            -- table enumeration+                   , [(((Int, Kind, Kind), [SV]), [String])]     -- constant tables+                   , [(((Int, Kind, Kind), [SV]), [String])]     -- non-constant tables+                   )+constructTables rm consts tbls = (tableMap, constTables, nonConstTables)+ where allTables      = [(t, genTableData rm (map fst consts) t) | t <- tbls]+       constTables    = [(t, d) | (t, Left  d) <- allTables]+       nonConstTables = [(t, d) | (t, Right d) <- allTables]+       tableMap       = IM.fromList $ map grab allTables++       grab (((t, _, _), _), _) = (t, "table" ++ show t)+ -- Left if all constants, Right if otherwise genTableData :: RoundingMode -> [SV] -> ((Int, Kind, Kind), [SV]) -> Either [String] [String] genTableData rm consts ((i, aknd, _), elts)@@ -780,6 +797,9 @@          addRM s = s ++ " " ++ smtRoundingMode rm +        hd _ (a:_) = a+        hd w []    = error $ "Impossible: " ++ w ++ ": Received empty list of args!"+         -- lift a binary op         lift2  o _ [x, y] = "(" ++ o ++ " " ++ x ++ " " ++ y ++ ")"         lift2  o _ sbvs   = error $ "SBV.SMTLib2.sh.lift2: Unexpected arguments: "   ++ show (o, sbvs)@@ -796,13 +816,14 @@          liftAbs sgned args | fpOp        = lift1 "fp.abs" sgned args                            | intOp       = lift1 "abs"    sgned args-                           | bvOp, sgned = mkAbs (head args) "bvslt" "bvneg"-                           | bvOp        = head args-                           | True        = mkAbs (head args) "<"     "-"-          where mkAbs x cmp neg = "(ite " ++ ltz ++ " " ++ nx ++ " " ++ x ++ ")"+                           | bvOp, sgned = mkAbs fArg "bvslt" "bvneg"+                           | bvOp        = fArg+                           | True        = mkAbs fArg "<"     "-"+          where fArg = hd "liftAbs" args+                mkAbs x cmp neg = "(ite " ++ ltz ++ " " ++ nx ++ " " ++ x ++ ")"                   where ltz = "(" ++ cmp ++ " " ++ x ++ " " ++ z ++ ")"                         nx  = "(" ++ neg ++ " " ++ x ++ ")"-                        z   = cvtCV rm (mkConstCV (kindOf (head arguments)) (0::Integer))+                        z   = cvtCV rm (mkConstCV (kindOf (hd "liftAbs.arguments" arguments)) (0::Integer))          lift2B bOp vOp           | boolOp = lift2 bOp@@ -837,7 +858,7 @@                       | True = lift2 o          unintComp o [a, b]-          | KUserSort s (Just _) <- kindOf (head arguments)+          | KUserSort s (Just _) <- kindOf (hd "unintComp" arguments)           = let idx v = "(" ++ s ++ "_constrIndex " ++ v ++ ")" in "(" ++ o ++ " " ++ idx a ++ " " ++ idx b ++ ")"         unintComp o sbvs = error $ "SBV.SMT.SMTLib2.sh.unintComp: Unexpected arguments: "   ++ show (o, sbvs, map kindOf arguments) @@ -845,7 +866,7 @@         stringOrChar KChar   = True         stringOrChar _       = False         stringCmp swap o [a, b]-          | stringOrChar (kindOf (head arguments))+          | stringOrChar (kindOf (hd "stringCmp" arguments))           = let (a1, a2) | swap = (b, a)                          | True = (a, b)             in "(" ++ o ++ " " ++ a1 ++ " " ++ a2 ++ ")"@@ -853,7 +874,7 @@          -- NB. Likewise for sequences         seqCmp swap o [a, b]-          | KList{} <- kindOf (head arguments)+          | KList{} <- kindOf (hd "seqCmp" arguments)           = let (a1, a2) | swap = (b, a)                          | True = (a, b)             in "(" ++ o ++ " " ++ a1 ++ " " ++ a2 ++ ")"@@ -1010,8 +1031,7 @@           | True  = reducePB pb args'           where args' = map cvtSV args -        -- NB: Z3 semantics have the predicates reversed: i.e., it returns true if overflow isn't possible. Hence the not.-        sh (SBVApp (OverflowOp op) args) = "(not (" ++ show op ++ " " ++ unwords (map cvtSV args) ++ "))"+        sh (SBVApp (OverflowOp op) args) = "(" ++ show op ++ " " ++ unwords (map cvtSV args) ++ ")"          -- Note the unfortunate reversal in StrInRe..         sh (SBVApp (StrOp (StrInRe r)) args) = "(str.in.re " ++ unwords (map cvtSV args) ++ " " ++ regExpToSMTString r ++ ")"@@ -1039,7 +1059,6 @@         sh (SBVApp (SetOp SetSubset)     args)   = "(subset "       ++ unwords (map cvtSV args) ++ ")"         sh (SBVApp (SetOp SetDifference) args)   = "(setminus "     ++ unwords (map cvtSV args) ++ ")"         sh (SBVApp (SetOp SetComplement) args)   = "(complement "   ++ unwords (map cvtSV args) ++ ")"-        sh (SBVApp (SetOp SetHasSize)    args)   = "(set-has-size " ++ unwords (map cvtSV args) ++ ")"          sh (SBVApp (TupleConstructor 0)   [])    = "mkSBVTuple0"         sh (SBVApp (TupleConstructor n)   args)  = "((as mkSBVTuple" ++ show n ++ " " ++ smtType (KTuple (map kindOf args)) ++ ") " ++ unwords (map cvtSV args) ++ ")"@@ -1082,7 +1101,7 @@           | Just f <- lookup op uninterpretedTable           = f (map cvtSV args)           | True-          = if not (null args) && isUserSort (head args)+          = if not (null args) && isUserSort (hd "isUserSort" args)             then error $ unlines [ ""                                  , "*** Cannot translate operator        : " ++ show op                                  , "*** When applied to arguments of kind: " ++ intercalate ", " (nub (map (show . kindOf) args))
Data/SBV/SMT/Utils.hs view
@@ -41,34 +41,34 @@ import System.Exit (ExitCode(..))  -- | An instance of SMT-Lib converter; instantiated for SMT-Lib v1 and v2. (And potentially for newer versions in the future.)-type SMTLibConverter a =  QueryContext                                  -- ^ Internal or external query?-                       -> ProgInfo                                      -- ^ Various program info-                       -> Set.Set Kind                                  -- ^ Kinds used in the problem-                       -> Bool                                          -- ^ is this a sat problem?-                       -> [String]                                      -- ^ extra comments to place on top-                       -> ResultInp                                     -- ^ inputs or params-                       -> (CnstMap, [(SV, CV)])                         -- ^ constants. The map, and as rendered in order-                       -> [((Int, Kind, Kind), [SV])]                   -- ^ auto-generated tables-                       -> [(Int, ArrayInfo)]                            -- ^ user specified arrays-                       -> [(String, (Maybe [String], SBVType))]         -- ^ uninterpreted functions/constants-                       -> [SMTDef]                                      -- ^ user given axioms/definitions-                       -> SBVPgm                                        -- ^ assignments-                       -> S.Seq (Bool, [(String, String)], SV)          -- ^ extra constraints-                       -> SV                                            -- ^ output variable-                       -> SMTConfig                                     -- ^ configuration+type SMTLibConverter a =  QueryContext                                   -- ^ Internal or external query?+                       -> ProgInfo                                       -- ^ Various program info+                       -> Set.Set Kind                                   -- ^ Kinds used in the problem+                       -> Bool                                           -- ^ is this a sat problem?+                       -> [String]                                       -- ^ extra comments to place on top+                       -> ResultInp                                      -- ^ inputs or params+                       -> (CnstMap, [(SV, CV)])                          -- ^ constants. The map, and as rendered in order+                       -> [((Int, Kind, Kind), [SV])]                    -- ^ auto-generated tables+                       -> [(Int, ArrayInfo)]                             -- ^ user specified arrays+                       -> [(String, (Bool, Maybe [String], SBVType))]    -- ^ uninterpreted functions/constants+                       -> [(SMTDef, SBVType)]                            -- ^ user given axioms/definitions+                       -> SBVPgm                                         -- ^ assignments+                       -> S.Seq (Bool, [(String, String)], SV)           -- ^ extra constraints+                       -> SV                                             -- ^ output variable+                       -> SMTConfig                                      -- ^ configuration                        -> a  -- | An instance of SMT-Lib converter; instantiated for SMT-Lib v1 and v2. (And potentially for newer versions in the future.)-type SMTLibIncConverter a =  ProgInfo                              -- ^ Various prog info-                          -> [NamedSymVar]                         -- ^ inputs-                          -> Set.Set Kind                          -- ^ new kinds-                          -> (CnstMap, [(SV, CV)])                 -- ^ all constants sofar, and new constants-                          -> [(Int, ArrayInfo)]                    -- ^ newly created arrays-                          -> [((Int, Kind, Kind), [SV])]           -- ^ newly created tables-                          -> [(String, (Maybe [String], SBVType))] -- ^ newly created uninterpreted functions/constants-                          -> SBVPgm                                -- ^ assignments-                          -> S.Seq (Bool, [(String, String)], SV)  -- ^ extra constraints-                          -> SMTConfig                             -- ^ configuration+type SMTLibIncConverter a =  ProgInfo                                    -- ^ Various prog info+                          -> [NamedSymVar]                               -- ^ inputs+                          -> Set.Set Kind                                -- ^ new kinds+                          -> (CnstMap, [(SV, CV)])                       -- ^ all constants sofar, and new constants+                          -> [(Int, ArrayInfo)]                          -- ^ newly created arrays+                          -> [((Int, Kind, Kind), [SV])]                 -- ^ newly created tables+                          -> [(String, (Bool, Maybe [String], SBVType))] -- ^ newly created uninterpreted functions/constants+                          -> SBVPgm                                      -- ^ assignments+                          -> S.Seq (Bool, [(String, String)], SV)        -- ^ extra constraints+                          -> SMTConfig                                   -- ^ configuration                           -> a  -- | Create an annotated term
Data/SBV/Set.hs view
@@ -19,10 +19,6 @@ -- which is something you cannot do in Haskell! Conversely, you cannot compute -- the size of a symbolic set (as it can be infinite!), nor you can turn -- it into a list or necessarily enumerate its elements.------ __A note on cardinality__: You can indirectly talk about cardinality: 'Data.SBV.Set.hasSize'--- can be used to state that the set is finite and has size @k@ for a user-specified symbolic--- integer @k@. -----------------------------------------------------------------------------  {-# LANGUAGE Rank2Types          #-}@@ -42,7 +38,7 @@         , insert, delete          -- * Query-        , member, notMember, null, isEmpty, isFull, isUniversal, hasSize, isSubsetOf, isProperSubsetOf, disjoint+        , member, notMember, null, isEmpty, isFull, isUniversal, isSubsetOf, isProperSubsetOf, disjoint          -- * Combinations         , union, unions, intersection, intersections, difference, (\\)@@ -309,49 +305,6 @@ -- | Synonym for 'Data.SBV.Set.isFull'. isUniversal :: HasKind a => SSet a -> SBool isUniversal = isFull---- | Does the set have the given size? It implicitly asserts that the set--- 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.------ >>> sat $ \i -> hasSize (full :: SSet Integer) i--- Unsatisfiable------ 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 `union` b) k .=> k .>= i `smax` j--- > 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-  | Just (RegularSet a) <- unliteral sa-  = literal (fromIntegral (Set.size a)) .== si--  -- Case 2: Constant complement set, will never have finite size-  | Just (ComplementSet _) <- unliteral sa-  = sFalse--  -- Case 3: Integer is constant, and is negative:-  | Just i <- unliteral si, i < 0-  = sFalse--  -- Otherwise, go symbolic-  | True-  = SBV $ SVal KBool $ Right $ cache r-  where r st = do sva <- sbvToSV st sa-                  svi <- sbvToSV st si-                  newExpr st KBool $ SBVApp (SetOp SetHasSize) [sva, svi]  -- | Subset test. --
Data/SBV/String.hs view
@@ -145,9 +145,6 @@ -- -- >>> prove $ \i -> i .>= 0 .&& i .<= 4 .=> "AAAAA" `strToCharAt` i .== literal 'A' -- Q.E.D.------ ->>> prove $ \s i c -> i `inRange` (0, length s - 1) .&& s `strToCharAt` i .== c .=> indexOf s (singleton c) .<= i--- Q.E.D. strToCharAt :: SString -> SInteger -> SChar strToCharAt s i   | Just cs <- unliteral s, Just ci <- unliteral i, ci >= 0, ci < genericLength cs, let c = C.ord (cs `genericIndex` ci)@@ -313,9 +310,6 @@  -- | @`indexOf` s sub@. Retrieves first position of @sub@ in @s@, @-1@ if there are no occurrences. -- Equivalent to @`offsetIndexOf` s sub 0@.------ ->>> prove $ \s i -> i .> 0 .&& i .< length s .=> indexOf s (subStr s i 1) .<= i--- Q.E.D. -- -- >>> prove $ \s1 s2 -> length s2 .> length s1 .=> indexOf s1 s2 .== -1 -- Q.E.D.
Data/SBV/Tools/BoundedFix.hs view
@@ -20,8 +20,8 @@ import Data.SBV  -- $setup--- >>> import Data.SBV -- >>> -- For doctest purposes only:+-- >>> import Data.SBV -- >>> 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/GenTest.hs view
@@ -82,9 +82,11 @@                                    ++ [ n ++ " :: " ++ getType vs                                       , n ++ " = [ " ++ intercalate ("\n" ++ pad ++  ", ") (map mkLine vs), pad ++ "]"                                       ]-  where n | null vname                 = "testVectors"-          | not (isAlpha (head vname)) = "tv" ++ vname-          | True                       = vname+  where n = case vname of+              ""                    -> "testVectors"+              f:_ | not (isAlpha f) -> "tv" ++ vname+                  | True            -> vname+         imports           | null vs               = []           | needsInt && needsWord = ["import Data.Int", "import Data.Word", ""]@@ -195,11 +197,15 @@               , "typedef struct {"               , "  struct {"               ]-           ++ (if null vs then [] else zipWith (mkField "i") (fst (head vs)) [(0::Int)..])+           ++ (case vs of+                 []       -> []+                 (i, _):_ -> zipWith (mkField "i") i [(0::Int)..])            ++ [ "  } input;"               , "  struct {"               ]-           ++ (if null vs then [] else zipWith (mkField "o") (snd (head vs)) [(0::Int)..])+           ++ (case vs of+                 []       -> []+                 (_, o):_ -> zipWith (mkField "o") o [(0::Int)..])            ++ [ "  } output;"               , "} " ++ n ++ "TestVector;"               , ""@@ -275,7 +281,10 @@           | True    = "printf(\"%*d. " ++ fmtString ++ "\\n\", " ++ show (length (show (length vs - 1))) ++ ", i"                     ++ concatMap ("\n           , " ++ ) (zipWith inp is [(0::Int)..] ++ zipWith out os [(0::Int)..])                     ++ ");"-          where (is, os) = head vs+          where (is, os) = case vs of+                             h:_ -> h+                             _   -> error "outLine: Impossible hapepned, empty vs!"+                 inp cv i = mkBool cv (n ++ "[i].input.i"  ++ show i)                 out cv i = mkBool cv (n ++ "[i].output.o" ++ show i)                 mkBool cv s = case kindOf cv of@@ -309,14 +318,18 @@                                           ++ [ "   in [ " ++ intercalate "\n      , " (map mkLine vs)                                              , "      ];"                                              ]-  where n | null vname                 = "testVectors"-          | not (isAlpha (head vname)) = "tv" ++ vname-          | True                       = vname+  where n = case vname of+              ""                    -> "testVectors"+              f:_ | not (isAlpha f) -> "tv" ++ vname+                  | True            -> vname+         blaster          | bigEndian = "map (\\s. s == \"1\") (explode (string_tl r))"          | True      = "rev (map (\\s. s == \"1\") (explode (string_tl r)))"+         toF True  = '1'         toF False = '0'+         blast cv = let noForte w = error "SBV.renderTest: " ++ w ++ " values are not supported when generating Forte test-cases."                    in case kindOf cv of                         KBool             -> [toF (cvToBool cv)]
Data/SBV/Tools/Overflow.hs view
@@ -48,67 +48,58 @@ -- >>> -- For doctest purposes only: -- >>> import Data.SBV --- | Detecting underflow/overflow conditions. For each function,--- the first result is the condition under which the computation--- underflows, and the second is the condition under which it--- overflows.+-- | Detecting overflow. Each function here will return 'sTrue' if the result will not fit in the target+-- type, i.e., if it overflows or underflows. class ArithOverflow a where   -- | Bit-vector addition. Unsigned addition can only overflow. Signed addition can underflow and overflow.   --   -- A tell tale sign of unsigned addition overflow is when the sum is less than minimum of the arguments.   ---  -- >>> prove $ \x y -> snd (bvAddO x (y::SWord16)) .<=> x + y .< x `smin` y+  -- >>> prove $ \x y -> bvAddO x (y::SWord16) .<=> x + y .< x `smin` y   -- Q.E.D.-  bvAddO :: a -> a -> (SBool, SBool)+  bvAddO :: a -> a -> SBool    -- | Bit-vector subtraction. Unsigned subtraction can only underflow. Signed subtraction can underflow and overflow.-  bvSubO :: a -> a -> (SBool, SBool)+  bvSubO :: a -> a -> SBool    -- | Bit-vector multiplication. Unsigned multiplication can only overflow. Signed multiplication can underflow and overflow.-  bvMulO     :: a -> a -> (SBool, SBool)--  -- | Same as 'bvMulO', except instead of doing the computation internally, it simply sends it off to z3 as a primitive.-  -- Obviously, only use if you have the z3 backend! Note that z3 provides this operation only when no logic is set,-  -- so make sure to call @setLogic Logic_NONE@ in your program!-  bvMulOFast :: a -> a -> (SBool, SBool)+  bvMulO :: a -> a -> SBool    -- | Bit-vector division. Unsigned division neither underflows nor overflows. Signed division can only overflow. In fact, for each   -- signed bitvector type, there's precisely one pair that overflows, when @x@ is @minBound@ and @y@ is @-1@:   ---  -- >>> allSat $ \x y -> snd (x `bvDivO` (y::SInt8))+  -- >>> allSat $ \x y -> x `bvDivO` (y::SInt8)   -- Solution #1:   --   s0 = -128 :: Int8   --   s1 =   -1 :: Int8   -- This is the only solution.--  bvDivO :: a -> a -> (SBool, SBool)+  bvDivO :: a -> a -> SBool    -- | Bit-vector negation. Unsigned negation neither underflows nor overflows. Signed negation can only overflow, when the argument is   -- @minBound@:   ---  -- >>> prove $ \x -> x .== minBound .<=> snd (bvNegO (x::SInt16))+  -- >>> prove $ \x -> x .== minBound .<=> bvNegO (x::SInt16)   -- Q.E.D.-  bvNegO :: a -> (SBool, SBool)+  bvNegO :: a -> SBool -instance ArithOverflow SWord8  where {bvAddO = l2 bvAddO; bvSubO = l2 bvSubO; bvMulO = l2 bvMulO; bvMulOFast = l2 bvMulOFast; bvDivO = l2 bvDivO; bvNegO = l1 bvNegO}-instance ArithOverflow SWord16 where {bvAddO = l2 bvAddO; bvSubO = l2 bvSubO; bvMulO = l2 bvMulO; bvMulOFast = l2 bvMulOFast; bvDivO = l2 bvDivO; bvNegO = l1 bvNegO}-instance ArithOverflow SWord32 where {bvAddO = l2 bvAddO; bvSubO = l2 bvSubO; bvMulO = l2 bvMulO; bvMulOFast = l2 bvMulOFast; bvDivO = l2 bvDivO; bvNegO = l1 bvNegO}-instance ArithOverflow SWord64 where {bvAddO = l2 bvAddO; bvSubO = l2 bvSubO; bvMulO = l2 bvMulO; bvMulOFast = l2 bvMulOFast; bvDivO = l2 bvDivO; bvNegO = l1 bvNegO}-instance ArithOverflow SInt8   where {bvAddO = l2 bvAddO; bvSubO = l2 bvSubO; bvMulO = l2 bvMulO; bvMulOFast = l2 bvMulOFast; bvDivO = l2 bvDivO; bvNegO = l1 bvNegO}-instance ArithOverflow SInt16  where {bvAddO = l2 bvAddO; bvSubO = l2 bvSubO; bvMulO = l2 bvMulO; bvMulOFast = l2 bvMulOFast; bvDivO = l2 bvDivO; bvNegO = l1 bvNegO}-instance ArithOverflow SInt32  where {bvAddO = l2 bvAddO; bvSubO = l2 bvSubO; bvMulO = l2 bvMulO; bvMulOFast = l2 bvMulOFast; bvDivO = l2 bvDivO; bvNegO = l1 bvNegO}-instance ArithOverflow SInt64  where {bvAddO = l2 bvAddO; bvSubO = l2 bvSubO; bvMulO = l2 bvMulO; bvMulOFast = l2 bvMulOFast; bvDivO = l2 bvDivO; bvNegO = l1 bvNegO}+instance ArithOverflow SWord8  where {bvAddO = l2 bvAddO; bvSubO = l2 bvSubO; bvMulO = l2 bvMulO; bvDivO = l2 bvDivO; bvNegO = l1 bvNegO}+instance ArithOverflow SWord16 where {bvAddO = l2 bvAddO; bvSubO = l2 bvSubO; bvMulO = l2 bvMulO; bvDivO = l2 bvDivO; bvNegO = l1 bvNegO}+instance ArithOverflow SWord32 where {bvAddO = l2 bvAddO; bvSubO = l2 bvSubO; bvMulO = l2 bvMulO; bvDivO = l2 bvDivO; bvNegO = l1 bvNegO}+instance ArithOverflow SWord64 where {bvAddO = l2 bvAddO; bvSubO = l2 bvSubO; bvMulO = l2 bvMulO; bvDivO = l2 bvDivO; bvNegO = l1 bvNegO}+instance ArithOverflow SInt8   where {bvAddO = l2 bvAddO; bvSubO = l2 bvSubO; bvMulO = l2 bvMulO; bvDivO = l2 bvDivO; bvNegO = l1 bvNegO}+instance ArithOverflow SInt16  where {bvAddO = l2 bvAddO; bvSubO = l2 bvSubO; bvMulO = l2 bvMulO; bvDivO = l2 bvDivO; bvNegO = l1 bvNegO}+instance ArithOverflow SInt32  where {bvAddO = l2 bvAddO; bvSubO = l2 bvSubO; bvMulO = l2 bvMulO; bvDivO = l2 bvDivO; bvNegO = l1 bvNegO}+instance ArithOverflow SInt64  where {bvAddO = l2 bvAddO; bvSubO = l2 bvSubO; bvMulO = l2 bvMulO; bvDivO = l2 bvDivO; bvNegO = l1 bvNegO} -instance (KnownNat n, BVIsNonZero n) => ArithOverflow (SWord n) where {bvAddO = l2 bvAddO; bvSubO = l2 bvSubO; bvMulO = l2 bvMulO; bvMulOFast = l2 bvMulOFast; bvDivO = l2 bvDivO; bvNegO = l1 bvNegO}-instance (KnownNat n, BVIsNonZero n) => ArithOverflow (SInt  n) where {bvAddO = l2 bvAddO; bvSubO = l2 bvSubO; bvMulO = l2 bvMulO; bvMulOFast = l2 bvMulOFast; bvDivO = l2 bvDivO; bvNegO = l1 bvNegO}+instance (KnownNat n, BVIsNonZero n) => ArithOverflow (SWord n) where {bvAddO = l2 bvAddO; bvSubO = l2 bvSubO; bvMulO = l2 bvMulO; bvDivO = l2 bvDivO; bvNegO = l1 bvNegO}+instance (KnownNat n, BVIsNonZero n) => ArithOverflow (SInt  n) where {bvAddO = l2 bvAddO; bvSubO = l2 bvSubO; bvMulO = l2 bvMulO; bvDivO = l2 bvDivO; bvNegO = l1 bvNegO}  instance ArithOverflow SVal where-  bvAddO     = signPick2 bvuaddo     bvsaddo-  bvSubO     = signPick2 bvusubo     bvssubo-  bvMulO     = signPick2 bvumulo     bvsmulo-  bvMulOFast = signPick2 bvumuloFast bvsmuloFast-  bvDivO     = signPick2 bvudivo     bvsdivo-  bvNegO     = signPick1 bvunego     bvsnego+  bvAddO     = signPick2 (svMkOverflow2 (PlusOv False)) (svMkOverflow2 (PlusOv True))+  bvSubO     = signPick2 (svMkOverflow2 (SubOv  False)) (svMkOverflow2 (SubOv  True))+  bvMulO     = signPick2 (svMkOverflow2 (MulOv  False)) (svMkOverflow2 (MulOv  True))+  bvDivO     = signPick2 (const (const svFalse))        (svMkOverflow2 DivOv)           -- unsigned division doesn't overflow+  bvNegO     = signPick1 (const svFalse)                (svMkOverflow1 NegOv)           -- unsigned unary negation doesn't overflow  -- | A class of checked-arithmetic operations. These follow the usual arithmetic, -- except make calls to 'Data.SBV.sAssert' to ensure no overflow/underflow can occur.@@ -193,45 +184,6 @@   (/!)          = checkOp2 ?loc "division"       sDiv   bvDivO   negateChecked = checkOp1 ?loc "unary negation" negate bvNegO ---- | Zero-extend to given bits-zx :: Int -> SVal -> SVal-zx n a- | n < sa = error $ "Data.SBV: Unexpected zero extension: from: " ++ show (intSizeOf a) ++ " to: " ++ show n- | True   = p `svJoin` a- where sa = intSizeOf a-       s  = hasSign a-       p  = svInteger (KBounded s (n - sa)) 0---- | Sign-extend to given bits. Note that we keep the signedness of the argument.-sx :: Int -> SVal -> SVal-sx n a- | n < sa = error $ "Data.SBV: Unexpected sign extension: from: " ++ show (intSizeOf a) ++ " to: " ++ show n- | True   = p `svJoin` a- where sa = intSizeOf a-       mk = svInteger $ KBounded (hasSign a) (n - sa)-       p  = svIte (pos a) (mk 0) (mk (-1))---- | Get the sign-bit-signBit :: SVal -> SVal-signBit x = x `svTestBit` (intSizeOf x - 1)---- | Is the sign-bit high?-neg :: SVal -> SVal-neg x = signBit x `svEqual` svTrue---- | Is the sign-bit low?-pos :: SVal -> SVal-pos x = signBit x `svEqual` svFalse---- | Do these have the same sign?-sameSign :: SVal -> SVal -> SVal-sameSign x y = (pos x `svAnd` pos y) `svOr` (neg x `svAnd` neg y)---- | Do these have opposing signs?-diffSign :: SVal -> SVal -> SVal-diffSign x y = svNot (sameSign x y)- -- | Check all true svAll :: [SVal] -> SVal svAll = foldr svAnd svTrue@@ -254,155 +206,6 @@   = svAll [svTestBit x i `svEqual` svTrue | i <- [m, m-1 .. n]]   where sz = intSizeOf x --- | Unsigned addition. Can only overflow.-bvuaddo :: Int -> SVal -> SVal -> (SVal, SVal)-bvuaddo n x y = (underflow, overflow)-  where underflow = svFalse--        n'       = n+1-        overflow = neg $ zx n' x `svPlus` zx n' y---- | Signed addition.-bvsaddo :: Int -> SVal -> SVal -> (SVal, SVal)-bvsaddo _n x y = (underflow, overflow)-  where underflow = svAll [neg x, neg y, pos (x `svPlus` y)]-        overflow  = svAll [pos x, pos y, neg (x `svPlus` y)]---- | Unsigned subtraction. Can only underflow.-bvusubo :: Int -> SVal -> SVal -> (SVal, SVal)-bvusubo _n x y = (underflow, overflow)-  where underflow = y `svGreaterThan` x-        overflow  = svFalse---- | Signed subtraction.-bvssubo :: Int -> SVal -> SVal -> (SVal, SVal)-bvssubo _n x y = (underflow, overflow)-  where underflow = svAll [neg x, pos y, pos (x `svMinus` y)]-        overflow  = svAll [pos x, neg y, neg (x `svMinus` y)]---- | Unsigned multiplication. Can only overflow.-bvumulo :: Int -> SVal -> SVal -> (SVal, SVal)-bvumulo 0 _ _ = (svFalse,   svFalse)-bvumulo n x y = (underflow, overflow)-  where underflow = svFalse--        n1        = n+1-        overflow1 = signBit $ zx n1 x `svTimes` zx n1 y--        -- From Z3 sources:-        ---        -- expr_ref ovf(m()), v(m()), tmp(m());-        -- ovf = m().mk_false();-        -- v = m().mk_false();-        -- for (unsigned i = 1; i < sz; ++i) {-        --    mk_or(ovf, a_bits[sz-i], ovf);-        --    mk_and(ovf, b_bits[i], tmp);-        --    mk_or(tmp, v, v);-        -- }-        -- overflow2 = v;-        ---        overflow2 = go 1 svFalse svFalse-          where go i ovf v-                 | i >= n = v-                 | True   = go (i+1) ovf' v'-                 where ovf' = ovf  `svOr`  (x `svTestBit` (n-i))-                       tmp  = ovf' `svAnd` (y `svTestBit` i)-                       v'   = tmp `svOr` v--        overflow = overflow1 `svOr` overflow2---- | Signed multiplication.-bvsmulo :: Int -> SVal -> SVal -> (SVal, SVal)-bvsmulo 0 _ _ = (svFalse,   svFalse)-bvsmulo n x y = (underflow, overflow)-  where underflow = diffSign x y `svAnd` overflowPossible-        overflow  = sameSign x y `svAnd` overflowPossible--        n1        = n+1-        overflow1 = (xy1 `svTestBit` n) `svXOr` (xy1 `svTestBit` (n-1))-           where xy1 = sx n1 x `svTimes` sx n1 y--        -- From Z3 sources:-        -- expr_ref v(m()), tmp(m()), a(m()), b(m()), a_acc(m()), sign(m());-        -- a_acc = m().mk_false();-        -- v = m().mk_false();-        -- for (unsigned i = 1; i + 1 < sz; ++i) {-        --    mk_xor(b_bits[sz-1], b_bits[i], b);-        --    mk_xor(a_bits[sz-1], a_bits[sz-1-i], a);-        --    mk_or(a, a_acc, a_acc);-        --    mk_and(a_acc, b, tmp);-        --    mk_or(tmp, v, v);-        -- }-        -- overflow2 = v;-        overflow2 = go 1 svFalse svFalse-           where sY = signBit y-                 sX = signBit x-                 go i v a_acc-                  | i + 1 >= n = v-                  | True       = go (i+1) v' a_acc'-                  where b      = sY `svXOr` (y `svTestBit` i)-                        a      = sX `svXOr` (x `svTestBit` (n-1-i))-                        a_acc' = a `svOr` a_acc-                        tmp    = a_acc' `svAnd` b-                        v'     = tmp `svOr` v--        overflowPossible = overflow1 `svOr` overflow2---- | Is this a concrete value?-known :: SVal -> Bool-known (SVal _ (Left _)) = True-known _                 = False---- | Unsigned multiplication, fast version using z3 primitives.-bvumuloFast :: Int -> SVal -> SVal -> (SVal, SVal)-bvumuloFast n x y-   | known x && known y                         -- Not particularly fast, but avoids shipping of to the solver-   = bvumulo n x y-   | True-   = (underflow, overflow)-  where underflow = fst $ bvumulo n x y         -- No internal version for underflow exists (because it can't underflow)-        overflow  = svMkOverflow Overflow_UMul_OVFL x y---- | Signed multiplication, fast version using z3 primitives.-bvsmuloFast :: Int -> SVal -> SVal -> (SVal, SVal)-bvsmuloFast n x y-  | known x && known y                -- Not particularly fast, but avoids shipping of to the solver-  = bvsmulo n x y-  | True-  = (underflow, overflow)-  where underflow = svMkOverflow Overflow_SMul_UDFL x y-        overflow  = svMkOverflow Overflow_SMul_OVFL x y---- | Unsigned division. Neither underflows, nor overflows.-bvudivo :: Int -> SVal -> SVal -> (SVal, SVal)-bvudivo _ _ _ = (underflow, overflow)-  where underflow = svFalse-        overflow  = svFalse---- | Signed division. Can only overflow.-bvsdivo :: Int -> SVal -> SVal -> (SVal, SVal)-bvsdivo n x y = (underflow, overflow)-  where underflow = svFalse--        ones      = svInteger (KBounded True n) (-1)-        topSet    = svInteger (KBounded True n) (2^(n-1))--        overflow = svAll [x `svEqual` topSet, y `svEqual` ones]---- | Unsigned negation. Neither underflows, nor overflows.-bvunego :: Int -> SVal -> (SVal, SVal)-bvunego _ _ = (underflow, overflow)-  where underflow = svFalse-        overflow  = svFalse---- | Signed negation. Can only overflow.-bvsnego :: Int -> SVal -> (SVal, SVal)-bvsnego n x = (underflow, overflow)-  where underflow = svFalse--        topSet    = svInteger (KBounded True n) (2^(n-1))-        overflow  = x `svEqual` topSet- -- | Detecting underflow/overflow conditions for casting between bit-vectors. The first output is the result, -- the second component itself is a pair with the first boolean indicating underflow and the second indicating overflow. --@@ -491,38 +294,28 @@   -- Helpers-l2 :: (SVal -> SVal -> (SBool, SBool)) -> SBV a -> SBV a -> (SBool, SBool)+l2 :: (SVal -> SVal -> SBool) -> SBV a -> SBV a -> SBool l2 f (SBV a) (SBV b) = f a b -l1 :: (SVal -> (SBool, SBool)) -> SBV a -> (SBool, SBool)+l1 :: (SVal -> SBool) -> SBV a -> SBool l1 f (SBV a) = f a -signPick2 :: (Int -> SVal -> SVal -> (SVal, SVal)) -> (Int -> SVal -> SVal -> (SVal, SVal)) -> (SVal -> SVal -> (SBool, SBool))+signPick2 :: (SVal -> SVal -> SVal) -> (SVal -> SVal -> SVal) -> (SVal -> SVal -> SBool) signPick2 fu fs a b- | hasSign a = let (u, o) = fs n a b in (SBV u, SBV o)- | True      = let (u, o) = fu n a b in (SBV u, SBV o)- where n = intSizeOf a+ | hasSign a = SBV (fs a b)+ | True      = SBV (fu a b) -signPick1 :: (Int -> SVal -> (SVal, SVal)) -> (Int -> SVal -> (SVal, SVal)) -> (SVal -> (SBool, SBool))+signPick1 :: (SVal -> SVal) -> (SVal -> SVal) -> (SVal -> SBool) signPick1 fu fs a- | hasSign a = let (u, o) = fs n a in (SBV u, SBV o)- | True      = let (u, o) = fu n a in (SBV u, SBV o)- where n = intSizeOf a+ | hasSign a = SBV (fs a)+ | True      = SBV (fu a) -checkOp1 :: (HasKind a, HasKind b) => CallStack -> String -> (a -> SBV b) -> (a -> (SBool, SBool)) -> a -> SBV b-checkOp1 loc w op cop a = sAssert (Just loc) (msg "underflows") (sNot u)-                        $ sAssert (Just loc) (msg "overflows")  (sNot o)-                        $ op a+checkOp1 :: (HasKind a, HasKind b) => CallStack -> String -> (a -> SBV b) -> (a -> SBool) -> a -> SBV b+checkOp1 loc w op cop a = sAssert (Just loc) (msg "overflows") (sNot (cop a)) $ op a   where k = show $ kindOf a         msg c = k ++ " " ++ w ++ " " ++ c -        (u, o) = cop a--checkOp2 :: (HasKind a, HasKind c) => CallStack -> String -> (a -> b -> SBV c) -> (a -> b -> (SBool, SBool)) -> a -> b -> SBV c-checkOp2 loc w op cop a b = sAssert (Just loc) (msg "underflows") (sNot u)-                          $ sAssert (Just loc) (msg "overflows")  (sNot o)-                          $ a `op` b+checkOp2 :: (HasKind a, HasKind c) => CallStack -> String -> (a -> b -> SBV c) -> (a -> b -> SBool) -> a -> b -> SBV c+checkOp2 loc w op cop a b = sAssert (Just loc) (msg "overflows")  (sNot (a `cop` b)) $ a `op` b   where k = show $ kindOf a         msg c = k ++ " " ++ w ++ " " ++ c--        (u, o) = a `cop` b
Data/SBV/Tools/Polynomial.hs view
@@ -202,7 +202,7 @@ divx n i xs ys'        = (q:qs, rs)   where q        = xs `idx` i         xs'      = ites q (xs `addPoly` ys') xs-        (qs, rs) = divx (n-1) (i-1) xs' (tail ys')+        (qs, rs) = divx (n-1) (i-1) xs' (drop 1 ys')  -- | Compute CRCs over bit-vectors. The call @crcBV n m p@ computes -- the CRC of the message @m@ with respect to polynomial @p@. The@@ -242,7 +242,10 @@         go c []     = c         go c (b:bs) = go next bs           where c' = drop 1 c ++ [b]-                next = ite (head c) (zipWith (.<+>) c' mask) c'+                next = ite (hd c) (zipWith (.<+>) c' mask) c'++                hd (f:_) = f+                hd []    = error "crcBV: Impossible, prefix is empty"  -- | Compute CRC's over polynomials, i.e., symbolic words. The first -- 'Int' argument plays the same role as the one in the 'crcBV' function.
Data/SBV/Utils/SExpr.hs view
@@ -546,11 +546,13 @@ -- This isn't very fool-proof; can be confused if there are binding constructs etc. -- Also, the generated text isn't necessarily fully Haskell acceptable. -- But it seems to do an OK job for most common use cases.-makeHaskellFunction :: String -> String -> Maybe [String] -> Maybe String-makeHaskellFunction resp nm mbArgs+makeHaskellFunction :: String -> String -> Bool -> Maybe [String] -> Maybe String+makeHaskellFunction resp nm isCurried mbArgs    = case parseSExpr resp of        Right (EApp [EApp [ECon o, e]]) | o == nm -> do (args, bd) <- lambda e-                                                       return $ unwords (nm : args) ++ " = " ++ bd+                                                       let params | isCurried = unwords args+                                                                  | True      = '(' : intercalate ", " args ++ ")"+                                                       return $ nm ++ " " ++ params ++ " = " ++ bd        _                                         -> Nothing    where -- infinite supply of names; starting with the ones we're given@@ -568,57 +570,113 @@         lambda :: SExpr -> Maybe ([String], String)         lambda (EApp [ECon "lambda", EApp args, bd]) = do as <- mapM getArg args                                                           let env = zip as supply-                                                          pure (map snd env, body env bd)+                                                          pure (map snd env, hprint env bd)         lambda _                                     = Nothing          getArg (EApp [ECon argName, _]) = Just argName         getArg _                        = Nothing -        body env = go-          where go :: SExpr -> String-                go (ECon n) | Just a <- lookup n env = a-                            | True                   = n+-- Print as a Haskell expression, with minimal parens.+-- This isn't fool-proof; but it does an OK job+hprint :: [(String, String)] -> SExpr -> String+hprint env = go (0 :: Int)+  where sanitize = map clean -                go (ENum (i, _))      = show i-                go (EReal  a)         = show a-                go (EFloat f)         = show f-                go (EFloatingPoint f) = show f-                go (EDouble f)        = show f-                go (EApp xs)          = app (map (wrap . go) xs)+        -- z3 uses ! as part of names, replace with _+        clean '!' = '_'+        clean c   = c -                parens x = '(' : x ++ ")"+        go p e = case e of+                   ECon n | Just a <- n `lookup` env -> a+                          | True                     -> sanitize n+                   ENum (i, _)       -> cnst i+                   EReal  a          -> cnst a+                   EFloat f          -> cnst f+                   EFloatingPoint f  -> cnst f+                   EDouble f         -> cnst f -                wrap x | "-" `isPrefixOf` x = parens x-                       | any isSpace x      = parens x-                       | True               = x+                   -- Handle lets+                   EApp [ECon "let", EApp binders, rhs] ->+                       let getBind (EApp [ECon nm, def]) = sanitize nm ++ " = " ++  go 0 def+                           getBind bnd                   = go 0 bnd -                mkBin o a b = wrap a ++ " " ++ o ++ " " ++ wrap b+                           binds = '{' : intercalate "; " (map getBind binders) ++ "}"+                       in parenIf (p >= 1) $ "let " ++ binds ++ " in " ++ go 0 rhs -                isPlus  = (`elem` ["+",  "bvadd"])-                isTimes = (`elem` ["*",  "bvmul"])-                isLT    = (`elem` ["<",  "bvult", "bvslt", "fp.lt" ])-                isLTE   = (`elem` ["<=", "bvule", "bvsle", "fp.leq"])-                isGT    = (`elem` [">",  "bvugt", "bvsgt", "fp.gt" ])-                isGTE   = (`elem` [">=", "bvuge", "bvsge", "fp.gte"])+                   -- few simps+                   EApp [ECon "not", EApp [ECon ">=", a, b]] -> go p $ EApp [ECon "<",  a, b]+                   EApp [ECon "not", EApp [ECon "<=", a, b]] -> go p $ EApp [ECon ">",  a, b]+                   EApp [ECon "not", EApp [ECon "<",  a, b]] -> go p $ EApp [ECon ">=", a, b]+                   EApp [ECon "not", EApp [ECon ">",  a, b]] -> go p $ EApp [ECon "<=", a, b] -                -- Make an application, with some simplifications-                app :: [String] -> String-                app (o : xs) | isPlus o = intercalate " + " xs+                   -- Handle x + -y that z3 is fond of producing+                   EApp [ECon a, x, EApp [ECon m, ENum (-1, _), y]] | isPlus a && isTimes m -> go p $ EApp [ECon "-", x, y] -                -- multiplication of arbitrary elements, with proviso for multiplication by -1-                app [m, "(-1)", x] | isTimes m = '-' : x-                app (m  : xs)      | isTimes m = intercalate " * " xs+                   -- Handle x + -NUM that z3 is also fond of producing+                   EApp [ECon a, x, ENum (i, mw)] | isPlus a && i < 0 -> go p $ EApp [ECon "-", x, ENum (-i, mw)] -                -- binary arith ops-                app ["-",  a, b] = mkBin "-"  a b-                app ["/",  a, b] = mkBin "/"  a b+                   -- Handle -1 * x+                   EApp [ECon o, ENum (-1, _), b] | isTimes o -> parenIf (p >= 8) (neg (go 8 b)) -                app [o, a, b] | isLT  o = mkBin "<"  a b-                app [o, a, b] | isLTE o = mkBin "<=" a b-                app [o, a, b] | isGT  o = mkBin ">"  a b-                app [o, a, b] | isGTE o = mkBin ">=" a b+                   -- Move additive constants to the right, multiplicative constants to the left+                   EApp [ECon o, x, y] | isPlus  o && isConst x && not (isConst y) -> go p $ EApp [ECon o, y, x]+                   EApp [ECon o, x, y] | isTimes o && isConst y && not (isConst x) -> go p $ EApp [ECon o, y, x] -                -- give up, and just do prefix!-                app xs = unwords xs+                   -- Simp arithmetic+                   EApp (ECon o : xs) | isPlus  o -> recurse 6 (Just "+")  xs+                   EApp (ECon o : xs) | isMinus o -> recurse 6 (Just "-")  xs+                   EApp (ECon o : xs) | isTimes o -> recurse 7 (Just "*")  xs+                   EApp (ECon o : xs) | isDiv   o -> recurse 7 (Just "/")  xs++                   -- Booleans+                   EApp (ECon o : xs) | isLT    o -> recurse 4 (Just "<")  xs+                   EApp (ECon o : xs) | isLTE   o -> recurse 4 (Just "<=") xs+                   EApp (ECon o : xs) | isGT    o -> recurse 4 (Just ">")  xs+                   EApp (ECon o : xs) | isGTE   o -> recurse 4 (Just ">=") xs+                   EApp (ECon o : xs) | isAND   o -> recurse 3 (Just "&&") xs+                   EApp (ECon o : xs) | isOR    o -> recurse 2 (Just "||") xs+                   EApp (ECon o : xs) | isEQ    o -> recurse 4 (Just "==") xs++                   -- Otherwise, just do prefix+                   EApp xs                        -> recurse 9 Nothing xs++           where recurse p' (Just op) xs = parenIf (p >= p') $ intercalate (' ' : op ++ " ") (map (parenNeg . go p') xs)+                 recurse p' Nothing   xs = parenIf (p >= p') $ unwords                       (map (parenNeg . go p') xs)++        isConst ECon          {} = False+        isConst ENum          {} = True+        isConst EReal         {} = True+        isConst EFloat        {} = True+        isConst EFloatingPoint{} = True+        isConst EDouble       {} = True+        isConst EApp          {} = False++        parenNeg x@('-':_) = paren x+        parenNeg x         = x++        neg ('-':x) = x+        neg x       = '-' : parenIf (any isSpace x) x++        cnst x = case show x of+                  sx@('-' : _) -> paren sx+                  sx           -> sx++        paren r@('(':_) = r+        paren r         = '(' : r ++ ")"++        parenIf False r = r+        parenIf True  r = paren r++        isPlus  = (`elem` ["+",  "bvadd"])+        isTimes = (`elem` ["*",  "bvmul"])+        isMinus = (`elem` ["-",  "bvsub"])+        isDiv   = (`elem` ["/",  "bvdiv"])+        isLT    = (`elem` ["<",  "bvult", "bvslt", "fp.lt" ])+        isLTE   = (`elem` ["<=", "bvule", "bvsle", "fp.leq"])+        isGT    = (`elem` [">",  "bvugt", "bvsgt", "fp.gt" ])+        isGTE   = (`elem` [">=", "bvuge", "bvsge", "fp.gte"])+        isEQ    = (`elem` ["=",  "fp.eq"])+        isAND   = (== "and")+        isOR    = (== "or")  {- HLint ignore chainAssigns "Redundant if" -}
Documentation/SBV/Examples/BitPrecise/BrokenSearch.hs view
@@ -26,15 +26,15 @@ -- -- >>> checkArithOverflow midPointBroken -- ./Documentation/SBV/Examples/BitPrecise/BrokenSearch.hs:39:32:+!: SInt32 addition overflows: Violated. Model:---   low  = 2147475456 :: Int32---   high = 2147483646 :: Int32+--   low  = 1073741832 :: Int32+--   high = 1107296257 :: Int32 -- -- Indeed: ----- >>> (2147475456 + 2147483646) `div` (2::Int32)--- -4097+-- >>> (1073741832 + 1107296257) `div` (2::Int32)+-- -1056964604 ----- giving us a negative mid-point value!+-- giving us quite a large negative mid-point value! midPointBroken :: SInt32 -> SInt32 -> SInt32 midPointBroken low high = (low +! high) /! 2
− Documentation/SBV/Examples/BitPrecise/MultMask.hs 
@@ -1,61 +0,0 @@--------------------------------------------------------------------------------- |--- Module    : Documentation.SBV.Examples.BitPrecise.MultMask--- Copyright : (c) Levent Erkok--- License   : BSD3--- Maintainer: erkokl@gmail.com--- Stability : experimental------ An SBV solution to the bit-precise puzzle of shuffling the bits in a--- 64-bit word in a custom order. The idea is to take a 64-bit value:------    @1.......2.......3.......4.......5.......6.......7.......8.......@------ And turn it into another 64-bit value, that looks like this:------    @12345678........................................................@------ We do not care what happens to the bits that are represented by dots. The--- problem is to do this with one mask and one multiplication.------ Apparently this operation has several applications, including in programs--- that play chess of all things. We use SBV to find the appropriate mask and--- the multiplier.------ Note that this is an instance of the program synthesis problem, where--- we "fill in the blanks" given a certain skeleton that satisfy a certain--- property, using quantified formulas.--------------------------------------------------------------------------------{-# OPTIONS_GHC -Wall -Werror #-}--module Documentation.SBV.Examples.BitPrecise.MultMask where--import Data.SBV-import Data.SBV.Control---- | Find the multiplier and the mask as described. We have:------ >>> maskAndMult--- Satisfiable. Model:---   mask = 0x8080808080808080 :: Word64---   mult = 0x0002040810204081 :: Word64------ That is, any 64 bit value masked by the first and multiplied by the second--- value above will have its bits at positions @[7,15,23,31,39,47,55,63]@ moved--- to positions @[56,57,58,59,60,61,62,63]@ respectively.------ 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 -- Magic incantation to make the test go fast. See <http://github.com/Z3Prover/z3/issues/5660> for details.-                  setOption $ OptionKeyword ":smt.ematching" ["false"]--                  mask <- free "mask"-                  mult <- free "mult"-                  constrain $ \(Forall inp) -> let res = (mask .&. inp) * (mult :: SWord64)-                                                in inp `sExtractBits` [7, 15 .. 63] .== res `sExtractBits` [56 .. 63]
+ Documentation/SBV/Examples/BitPrecise/PEXT_PDEP.hs view
@@ -0,0 +1,162 @@+-----------------------------------------------------------------------------+-- |+-- Module    : Documentation.SBV.Examples.BitPrecise.PEXT_PDEP+-- Copyright : (c) Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+--+-- Models the x86 [PEXT](https://www.felixcloutier.com/x86/pext) and [PDEP](https://www.felixcloutier.com/x86/pdep) instructions.+--+-- The pseudo-code implementation given by Intel for PEXT (parallel extract) is:+--+-- @+--    TEMP := SRC1;+--    MASK := SRC2;+--    DEST := 0 ;+--    m := 0, k := 0;+--    DO WHILE m < OperandSize+--        IF MASK[m] = 1 THEN+--            DEST[k] := TEMP[m];+--            k := k+ 1;+--        FI+--        m := m+ 1;+--    OD+-- @+--+-- PDEP (parallel deposit) is similar, except the assigment is:+--+-- @+--    DEST[m] := TEMP[k]+-- @+--+-- In PEXT, we grab the values of the source corresponding to the mask, and pile them into the destination from the bottom. In PDEP, we+-- do the reverse: We distribute the bits from the bottom of the source to the destination according to the mask.+-----------------------------------------------------------------------------++{-# LANGUAGE DataKinds           #-}+{-# LANGUAGE Rank2Types          #-}+{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE TypeApplications    #-}++{-# OPTIONS_GHC -Wall -Werror #-}++module Documentation.SBV.Examples.BitPrecise.PEXT_PDEP where++import Data.SBV+import GHC.TypeLits (KnownNat)++-- $setup+-- >>> -- For doctest purposes only:+-- >>> import Data.SBV+-- >>> :set -XDataKinds++--------------------------------------------------------------------------------------------------+-- * Parallel extraction+--------------------------------------------------------------------------------------------------++-- | Parallel extraction: Given a source value and a mask, extract the bits in the source that are+-- pointed to by the mask, and put it in the destination starting from the bottom.+--+-- >>> satWith z3{printBase = 16} $ \r -> r .== pext (0xAA :: SWord 8) 0xAA+-- Satisfiable. Model:+--   s0 = 0x0f :: Word8+-- >>> prove $ \x -> pext @8 x 0 .== 0+-- Q.E.D.+-- >>> prove $ \x -> pext @8 x (complement 0) .== x+-- Q.E.D.+pext :: forall n. (KnownNat n, BVIsNonZero n) => SWord n -> SWord n -> SWord n+pext src mask = walk 0 src 0 (blastLE mask)+  where walk dest _ _   []     = dest+        walk dest x idx (m:ms) = walk (ite m (sSetBitTo dest idx (lsb x)) dest)+                                      (x `shiftR` 1)+                                      (ite m (idx + 1) idx)+                                      ms++--------------------------------------------------------------------------------------------------+-- * Parallel deposit+--------------------------------------------------------------------------------------------------++-- | Parallel deposit: Given a source value and a mask, write into the destination that are+-- allowed by the mask, grabbing the bits from the source starting from the bottom.+--+-- >>> satWith z3{printBase = 16} $ \r -> r .== pdep (0xFF :: SWord 8) 0xAA+-- Satisfiable. Model:+--   s0 = 0xaa :: Word8+-- >>> prove $ \x -> pdep @8 x 0 .== 0+-- Q.E.D.+-- >>> prove $ \x -> pdep @8 x (complement 0) .== x+-- Q.E.D.+pdep :: forall n. (KnownNat n, BVIsNonZero n) => SWord n -> SWord n -> SWord n+pdep src mask = walk 0 src 0 (blastLE mask)+  where walk dest _ _   []     = dest+        walk dest x idx (m:ms) = walk (ite m (sSetBitTo dest idx (lsb x)) dest)+                                      (ite m (x `shiftR` 1) x)+                                      (idx + 1)+                                      ms+--------------------------------------------------------------------------------------------------+-- * Round-trip property+--------------------------------------------------------------------------------------------------++-- | Prove that extraction and depositing with the same mask restore the source in all masked positions:+--+-- >>> extractThenDeposit+-- Q.E.D.+extractThenDeposit :: IO ThmResult+extractThenDeposit = prove $ do x :: SWord 8 <- sWord "x"+                                m :: SWord 8 <- sWord "m"+                                pure $ (x .&. m) .== pdep (pext x m) m++-- | Prove that depositing and extracting with the same mask will push preserve the bottom+-- n-bits of the source, where n is the number of bits set in the mask.+--+-- >>> depositThenExtract+-- Q.E.D.+depositThenExtract :: IO ThmResult+depositThenExtract = prove $ do x :: SWord 8 <- sWord "x"+                                m :: SWord 8 <- sWord "m"+                                let preserved = 2 .^ sPopCount m - 1+                                pure $ (x .&. preserved) .== pext (pdep x m) m++--------------------------------------------------------------------------------------------------+-- * Code generation+--------------------------------------------------------------------------------------------------++-- | We can generate the code for these functions if they need to be used in SMTLib. Below+-- is an example at 2-bits, which can be adjusted to produce any bit-size.+--+-- >>> putStrLn =<< sbv2smt pext_2+-- ; Automatically generated by SBV. Do not modify!+-- ; pext_2 :: SWord 2 -> SWord 2 -> SWord 2+-- (define-fun pext_2 ((l1_s0 (_ BitVec 2)) (l1_s1 (_ BitVec 2))) (_ BitVec 2)+--   (let ((l1_s3 #b0))+--   (let ((l1_s7 #b01))+--   (let ((l1_s8 #b00))+--   (let ((l1_s20 #b10))+--   (let ((l1_s2 ((_ extract 1 1) l1_s1)))+--   (let ((l1_s4 (distinct l1_s2 l1_s3)))+--   (let ((l1_s5 ((_ extract 0 0) l1_s1)))+--   (let ((l1_s6 (distinct l1_s3 l1_s5)))+--   (let ((l1_s9 (ite l1_s6 l1_s7 l1_s8)))+--   (let ((l1_s10 (= l1_s7 l1_s9)))+--   (let ((l1_s11 (bvlshr l1_s0 l1_s7)))+--   (let ((l1_s12 ((_ extract 0 0) l1_s11)))+--   (let ((l1_s13 (distinct l1_s3 l1_s12)))+--   (let ((l1_s14 (= l1_s8 l1_s9)))+--   (let ((l1_s15 ((_ extract 0 0) l1_s0)))+--   (let ((l1_s16 (distinct l1_s3 l1_s15)))+--   (let ((l1_s17 (ite l1_s16 l1_s7 l1_s8)))+--   (let ((l1_s18 (ite l1_s6 l1_s17 l1_s8)))+--   (let ((l1_s19 (bvor l1_s7 l1_s18)))+--   (let ((l1_s21 (bvand l1_s18 l1_s20)))+--   (let ((l1_s22 (ite l1_s13 l1_s19 l1_s21)))+--   (let ((l1_s23 (ite l1_s14 l1_s22 l1_s18)))+--   (let ((l1_s24 (bvor l1_s20 l1_s23)))+--   (let ((l1_s25 (bvand l1_s7 l1_s23)))+--   (let ((l1_s26 (ite l1_s13 l1_s24 l1_s25)))+--   (let ((l1_s27 (ite l1_s10 l1_s26 l1_s23)))+--   (let ((l1_s28 (ite l1_s4 l1_s27 l1_s18)))+--   l1_s28))))))))))))))))))))))))))))+pext_2 :: SWord 2 -> SWord 2 -> SWord 2+pext_2 = smtFunction "pext_2" (pext @2)
Documentation/SBV/Examples/Crypto/AES.hs view
@@ -24,10 +24,16 @@ -- are supported. ----------------------------------------------------------------------------- +{-# LANGUAGE CPP              #-} {-# LANGUAGE DataKinds        #-} {-# LANGUAGE ParallelListComp #-}+{-# LANGUAGE TypeApplications #-} +#if MIN_VERSION_base(4,19,0)+{-# OPTIONS_GHC -Wall -Werror -Wno-incomplete-uni-patterns -Wno-x-partial #-}+#else {-# OPTIONS_GHC -Wall -Werror -Wno-incomplete-uni-patterns #-}+#endif  module Documentation.SBV.Examples.Crypto.AES where @@ -40,6 +46,8 @@ import Data.List (transpose) import Data.Maybe (fromJust) +import Data.Proxy+ import Numeric (showHex)  import Test.QuickCheck hiding (verbose)@@ -693,13 +701,42 @@ -- 256 bit cases as well. aes128IsCorrect :: (SWord 32, SWord 32, SWord 32, SWord 32)  -- ^ plain-text words                 -> (SWord 32, SWord 32, SWord 32, SWord 32)  -- ^ key-words-                -> SBool                                 -- ^ True if round-trip gives us plain-text back+                -> SBool                                     -- ^ True if round-trip gives us plain-text back aes128IsCorrect (i0, i1, i2, i3) (k0, k1, k2, k3) = pt .== pt'    where pt  = [i0, i1, i2, i3]          key = [k0, k1, k2, k3]          (encKS, decKS) = aesKeySchedule key          ct  = aesEncrypt pt encKS          pt' = aesDecrypt ct decKS++-----------------------------------------------------------------------------+-- * Block encryption at full size+-----------------------------------------------------------------------------++-- | 128-bit encryption, that takes 128-bit values, instead of chunks. We have:+--+-- >>> hex8 $ aes128Enc 0x000102030405060708090a0b0c0d0e0f 0x00112233445566778899aabbccddeeff+-- "69c4e0d86a7b0430d8cdb78070b4c55a"+--+-- You can also render this function as a stand-alone function using:+--+-- @+--   sbv2smt (smtFunction "aes128Enc" aes128Enc)+-- @+aes128Enc :: SWord 128 -> SWord 128 -> SWord 128+aes128Enc key pt = from32 $ aesEncrypt (to32 pt) ks+  where to32 :: SWord 128 -> [SWord 32]+        to32 x = [ bvExtract (Proxy @127) (Proxy @96) x+                 , bvExtract (Proxy  @95) (Proxy @64) x+                 , bvExtract (Proxy  @63) (Proxy @32) x+                 , bvExtract (Proxy  @31) (Proxy  @0) x+                 ]++        from32 :: [SWord 32] -> SWord 128+        from32 [a, b, c, d] = a # b # c # d+        from32 _ = error "nope"++        (ks, _)  = aesKeySchedule (to32 key)  ----------------------------------------------------------------------------- -- * Code generation
− Documentation/SBV/Examples/Existentials/CRCPolynomial.hs 
@@ -1,82 +0,0 @@--------------------------------------------------------------------------------- |--- Module    : Documentation.SBV.Examples.Existentials.CRCPolynomial--- Copyright : (c) Levent Erkok--- License   : BSD3--- Maintainer: erkokl@gmail.com--- Stability : experimental------ This program demonstrates the use of the existentials and the QBVF (quantified--- bit-vector solver). We generate CRC polynomials of degree 16 that can be used--- for messages of size 48-bits. The query finds all such polynomials that have hamming--- distance is at least 4. That is, if the CRC can't tell two different 48-bit messages--- apart, then they must differ in at least 4 bits.--------------------------------------------------------------------------------{-# LANGUAGE DataKinds #-}--{-# OPTIONS_GHC -Wall -Werror #-}--module Documentation.SBV.Examples.Existentials.CRCPolynomial where--import Data.SBV-import Data.SBV.Tools.Polynomial---- | Compute the 16 bit CRC of a 48 bit message, using the given polynomial-crc_48_16 :: SWord 48 -> SWord16 -> [SBool]-crc_48_16 msg poly = crcBV 16 (blastBE msg) (blastBE poly)---- | Count the differing bits in the message and the corresponding CRC-diffCount :: (SWord 48, [SBool]) -> (SWord 48, [SBool]) -> SWord8-diffCount (d1, crc1) (d2, crc2) = count xorBits-  where bits1   = blastBE d1 ++ crc1-        bits2   = blastBE d2 ++ crc2-        -- xor will give us a false if bits match, true if they differ-        xorBits = zipWith (.<+>) bits1 bits2-        count []     = 0-        count (b:bs) = let r = count bs in ite b (1+r) r---- | Given a hamming distance value @hd@, 'crcGood' returns @true@ if--- the 16 bit polynomial can distinguish all messages that has at most--- @hd@ different bits. Note that we express this conversely: If the--- @sent@ and @received@ messages are different, then it must be the--- case that that must differ from each other (including CRCs), in--- more than @hd@ bits.-crcGood :: SWord8 -> SWord16 -> SWord 48 -> SWord 48 -> SBool-crcGood hd poly sent received =-     sent ./= received .=> diffCount (sent, crcSent) (received, crcReceived) .>= hd-   where crcSent     = crc_48_16 sent     poly-         crcReceived = crc_48_16 received poly---- | 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-                                poly <- free "polynomial" -- the polynomial is existentially specified-                                constrain $ \(Forall sent) (Forall received) ->-                                   -- 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-                                   -- polynomial, as all CRC polynomials have the "+1"-                                   -- term in them set. This simplifies the query.-                                   sTestBit poly 0 .&& crcGood hd poly sent received-                       cnt <- displayModels id disp res-                       putStrLn $ "Found: " ++ show cnt ++ " polynomial(s)."-        where disp :: Int -> (Bool, Word16) -> IO ()-              disp n (_, s) = putStrLn $ "Polynomial #" ++ show n ++ ". x^16 + " ++ showPolynomial False s---- | Find and display all degree 16 polynomials with hamming distance at least 4, for 48 bit messages.------ We have:------ >>> findHD4Polynomials 2--- Polynomial #1. x^16 + x^3 + x^2 + 1--- Polynomial #2. x^16 + x^2 + x + 1--- Found: 2 polynomial(s).------ Note that different runs can produce different results, depending on the random--- numbers used by the solver, solver version, etc. (Also, the solver will take some--- time to generate these results, as the generation of these polynomials is rather slow.)-findHD4Polynomials :: Int -> IO ()-findHD4Polynomials = genPoly 4--{- HLint ignore crc_48_16 "Use camelCase" -}
Documentation/SBV/Examples/Existentials/Diophantine.hs view
@@ -91,7 +91,9 @@                  constrain $ \(ForallN bs :: ForallN n nm Integer) ->                         ok as .&& (ok bs .=> as .== bs .|| sNot (bs `less` as)) -       n = if null m then 0 else length (head m)+       n = case m of+            []  -> 0+            f:_ -> length f         ok xs = sAny (.> 0) xs .&& sAll (.>= 0) xs .&& sAnd [sum (zipWith (*) r xs) .== 0 | r <- m] @@ -108,8 +110,8 @@ -- We have: -- -- >>> test--- (k', 2+k, k+2k')--- (1+k', k, k+2k')+-- (k, 2+k', 2k+k')+-- (1+k, k', 2k+k') -- -- That is, for arbitrary @k@ and @k'@, we have two different solutions. (An infinite family.) -- You can verify these solutuions by substituting the values for @x@, @y@ and @z@ in the above, for each choice.
− Documentation/SBV/Examples/Lists/Nested.hs 
@@ -1,45 +0,0 @@--------------------------------------------------------------------------------- |--- Module    : Documentation.SBV.Examples.Lists.Nested--- Copyright : (c) Levent Erkok--- License   : BSD3--- Maintainer: erkokl@gmail.com--- Stability : experimental------ Demonstrates nested lists--------------------------------------------------------------------------------{-# LANGUAGE OverloadedLists     #-}-{-# LANGUAGE ScopedTypeVariables #-}--{-# OPTIONS_GHC -Wall -Werror #-}--module Documentation.SBV.Examples.Lists.Nested where--import Data.SBV-import Data.SBV.Control--import Prelude hiding ((!!))-import Data.SBV.List ((!!))-import qualified Data.SBV.List as L---- | Simple example demonstrating the use of nested lists. We have:------ Turned off. See: https://github.com/Z3Prover/z3/issues/2820--- nestedExample--- [[1,2,3],[4,5,6,7],[8,9,10],[11,12,13]]-nestedExample :: IO ()-nestedExample = runSMT $ do a :: SList [Integer] <- free "a"--                            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--                            query $ do cs <- checkSat-                                       case cs of-                                         Unk    -> error "Solver said unknown!"-                                         DSat{} -> error "Unexpected dsat result.."-                                         Unsat  -> io $ putStrLn "Unsat"-                                         Sat    -> do v <- getValue a-                                                      io $ print v
Documentation/SBV/Examples/Misc/FirstOrderLogic.hs view
@@ -10,6 +10,7 @@ -- prove all come from <https://en.wikipedia.org/wiki/First-order_logic> ----------------------------------------------------------------------------- +{-# LANGUAGE CPP                 #-} {-# LANGUAGE DataKinds           #-} {-# LANGUAGE DeriveAnyClass      #-} {-# LANGUAGE DeriveDataTypeable  #-}@@ -18,6 +19,10 @@ {-# LANGUAGE TemplateHaskell     #-} {-# LANGUAGE TypeApplications    #-} +#if MIN_VERSION_base(4,19,0)+{-# LANGUAGE TypeAbstractions    #-}+#endif+ {-# OPTIONS_GHC -Wall -Werror #-}  module Documentation.SBV.Examples.Misc.FirstOrderLogic where@@ -200,7 +205,7 @@ --   b _ = 0 -- <BLANKLINE> --   d :: Word8 -> Word8 -> Word8---   d a c = a + (255 * c)+--   d a c = a + 255 * c -- -- Let's see what the solver said. It suggested we should use the value of @0@ for @b@, regardless of the -- choice of @a@. (Note how @b@ is a function of one variable, i.e., of @a@)@@ -271,7 +276,7 @@ --   c1_y x = x -- <BLANKLINE> --   c2_y :: Integer -> Integer---   c2_y x = 1 + x+--   c2_y x = x + 1 -- -- Note how the internal skolem functions are named according to the tag given. If you use regular 'skolemize' -- this program will essentially do the wrong thing by assuming the skolem functions for both predicates are
Documentation/SBV/Examples/Misc/Floating.hs view
@@ -66,19 +66,19 @@ -- -- >>> assocPlusRegular -- Falsifiable. Counter-example:---   x =  2097149.9 :: Float---   y =  13.999817 :: Float---   z = -1.9998167 :: Float+--   x = -1.7478492e-21 :: Float+--   y =   9.693523e-27 :: Float+--   z =   5.595795e-20 :: Float -- -- Indeed, we have: ----- >>> let x =  2097149.9 :: Float--- >>> let y =  13.999817 :: Float--- >>> let z = -1.9998167 :: Float+-- >>> let x = -1.7478492e-21 :: Float+-- >>> let y =   9.693523e-27 :: Float+-- >>> let z =   5.595795e-20 :: Float -- >>> x + (y + z)--- 2097162.0+-- 5.4210105e-20 -- >>> (x + y) + z--- 2097161.8+-- 5.421011e-20 -- -- Note the difference in the results! assocPlusRegular :: IO ThmResult@@ -100,13 +100,13 @@ -- -- >>> nonZeroAddition -- Falsifiable. Counter-example:---   a =   -7.441692e23 :: Float---   b = -7.5039685e-27 :: Float+--   a = 7.135861e-8 :: Float+--   b = 8.57579e-39 :: Float -- -- Indeed, we have: ----- >>> let a =   -7.441692e23 :: Float--- >>> let b = -7.5039685e-27 :: Float+-- >>> let a = 7.135861e-8 :: Float+-- >>> let b = 8.57579e-39 :: Float -- >>> a + b == a -- True -- >>> b == 0@@ -129,11 +129,11 @@ -- -- >>> multInverse -- Falsifiable. Counter-example:---   a = -5.69379e-39 :: Float+--   a = -1.4991268e38 :: Float -- -- Indeed, we have: ----- >>> let a = -5.69379e-39 :: Float+-- >>> let a = -1.4991268e38 :: Float -- >>> a * (1/a) -- 0.99999994 multInverse :: IO ThmResult@@ -156,27 +156,27 @@ -- >>> roundingAdd -- Satisfiable. Model: --   rm = RoundTowardZero :: RoundingMode---   x  =  -1.0579198e-37 :: Float---   y  =   4.7017266e-38 :: Float+--   x  =       1.7499695 :: Float+--   y  =       1.2539366 :: 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 sRoundTowardZero (-1.0579198e-37) (4.7017266e-38) :: SFPSingle--- -5.87747119e-38 :: SFloatingPoint 8 24--- >>> fpAdd sRoundNearestTiesToEven (-1.0579198e-37) (4.7017266e-38) :: SFPSingle--- -5.87747175e-38 :: SFloatingPoint 8 24+-- >>> fpAdd sRoundTowardZero 1.7499695 1.2539366 :: SFPSingle+-- 3.00390601 :: SFloatingPoint 8 24+-- >>> fpAdd sRoundNearestTiesToEven 1.7499695 1.2539366 :: SFPSingle+-- 3.00390625 :: SFloatingPoint 8 24 -- -- We can see why these two results are indeed different: The 'RoundTowardZero'--- (which rounds towards zero) produces a larger result, closer to 0. Indeed, if we treat these numbers+-- (which rounds towards the origin) produces a smaller result, closer to 0. Indeed, if we treat these numbers -- as 'Double' values, we get: ----- >>> (-1.0579198e-37) + (4.7017266e-38) :: Double--- -5.8774714e-38+-- >>>  1.7499695 + 1.2539366 :: Double+-- 3.0039061 ----- we see that the "more precise" result is larger than what the 'Float' value is, justifying the--- larger value with 'RoundTowardZero'. 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 'RoundTowardZero. 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/Newtypes.hs view
@@ -82,11 +82,11 @@ -- >>> sat problem -- Satisfiable. Model: --   floorToCeiling =   3 :: Integer---   humanheight    = 255 :: Word16+--   humanheight    = 272 :: Word16 problem :: Predicate problem = do     ceiling     :: SMetres          <- free "floorToCeiling"     humanHeight :: SHumanHeightInCm <- free "humanheight"-    constrain $ humanHeight .<= tallestHumanEver+    constrain $ humanHeight .== tallestHumanEver      return $ ceilingHighEnoughForHuman ceiling humanHeight
+ Documentation/SBV/Examples/Misc/ProgramPaths.hs view
@@ -0,0 +1,83 @@+-----------------------------------------------------------------------------+-- |+-- Module    : Documentation.SBV.Examples.Misc.ProgramPaths+-- Copyright : (c) Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- A simple example of showing how to compute program paths. Consider the simple+-- program:+-- +-- @+--   d1 x y = if y < x - 2  then   7 else   2+--   d2   y = if y > 3      then  10 else  50+--   d3 x y = if y < -x + 3 then 100 else 200+--   d4 x y = d1 x y + d2 y + d3 x y+-- @+--+-- What are all the possible values @d4 x y@ can take, and what are the values of+-- @x@ and @y@ to obtain these values?+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror #-}++module Documentation.SBV.Examples.Misc.ProgramPaths where++import Data.SBV++-- | Symbolic version of @d1 x y = if y < x - 2 then 7 else 2@+d1 :: SInteger -> SInteger -> SInteger+d1 x y = ite (y .< x - 2) 7 2++-- | Symbolic version of @d2 x y = if y > 3 then  10 else  50@+d2 :: SInteger -> SInteger+d2 y = ite (y .> 3) 10 50++-- | Symbolic version of @d3 x y = if y < -x + 3 then 100 else 200@+d3 :: SInteger -> SInteger -> SInteger+d3 x y = ite (y .< -x + 3) 100 200++-- | Symbolic version of @d4 x y = d1 x y + d2 x y + d3 x y@+d4 :: SInteger -> SInteger -> SInteger+d4 x y = d1 x y + d2 y + d3 x y++-- | Compute all possible program paths. Note the call to `partition`, which+-- causes `allSat` to find models that generate differing values for the given+-- expression. We have:+--+-- >>> paths+-- Solution #1:+--   x =  -2 :: Integer+--   y =   4 :: Integer+--   r = 112 :: Integer+-- Solution #2:+--   x =   0 :: Integer+--   y =   3 :: Integer+--   r = 252 :: Integer+-- Solution #3:+--   x =  -1 :: Integer+--   y =   4 :: Integer+--   r = 212 :: Integer+-- Solution #4:+--   x =   3 :: Integer+--   y =   0 :: Integer+--   r = 257 :: Integer+-- Solution #5:+--   x =   2 :: Integer+--   y =  -1 :: Integer+--   r = 157 :: Integer+-- Solution #6:+--   x =   7 :: Integer+--   y =   4 :: Integer+--   r = 217 :: Integer+-- Solution #7:+--   x =   0 :: Integer+--   y =   0 :: Integer+--   r = 152 :: Integer+-- Found 7 different solutions.+paths :: IO AllSatResult+paths = allSat $ do+  x <- sInteger "x"+  y <- sInteger "y"+  partition "r" $ d4 x y
+ Documentation/SBV/Examples/ProofTools/AddHorn.hs view
@@ -0,0 +1,106 @@+-----------------------------------------------------------------------------+-- |+-- Module    : Documentation.SBV.Examples.ProofTools.AddHorn+-- Copyright : (c) Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Example of invariant generation for a simple addition algorithm:+--+-- @+--    z = x+--    i = 0+--    assume y > 0+--+--    while (i < y)+--       z = z + 1+--       i = i + 1+--+--   assert z == x + y+-- @+--+-- We use the Horn solver to calculate the invariant and then show that it+-- indeed is a sufficient invariant to establish correctness.+-----------------------------------------------------------------------------++{-# LANGUAGE DataKinds #-}++{-# OPTIONS_GHC -Wall -Werror #-}++module Documentation.SBV.Examples.ProofTools.AddHorn where++import Data.SBV++-- $setup+-- >>> -- For doctest purposes only:+-- >>> import Data.SBV++-- | Helper type synonym for the invariant.+type Inv = (SInteger, SInteger, SInteger, SInteger) -> SBool++-- | Helper type synonym for verification conditions.+type VC = Forall "x" Integer -> Forall "y" Integer -> Forall "z" Integer -> Forall "i" Integer -> SBool++-- | Helper for turning an invariant predicate to a boolean.+quantify :: Inv -> VC+quantify f = \(Forall x) (Forall y) (Forall z) (Forall i) -> f (x, y, z, i)++-- | First verification condition: Before the loop starts, invariant must hold:+--+-- \(z = x \land i = 0 \land y > 0 \Rightarrow inv (x, y, z, i)\)+vc1 :: Inv -> VC+vc1 inv = quantify $ \(x, y, z, i) -> z .== x .&& i .== 0 .&& y .> 0 .=> inv (x, y, z, i)++-- | Second verification condition: If the loop body executes, invariant must still hold at the end:+--+-- \(inv (x, y, z, i) \land i < y \Rightarrow inv (x, y, z+1, i+1)\)+vc2 :: Inv -> VC+vc2 inv = quantify $ \(x, y, z, i) -> inv (x, y, z, i) .&& i .< y .=> inv (x, y, z+1, i+1)++-- | Third verification condition: Once the loop exits, invariant and the negation of the loop condition+-- must establish the final assertion:+--+-- \(inv (x, y, z, i) \land i \geq y \Rightarrow z == x + y\)+vc3 :: Inv -> VC+vc3 inv = quantify $ \(x, y, z, i) -> inv (x, y, z, i) .&& i .>= y .=> z .== x + y++-- | Synthesize the invariant. We use an uninterpreted function for the SMT solver to synthesize. We get:+--+-- >>> synthesize+-- Satisfiable. Model:+--   invariant :: (Integer, Integer, Integer, Integer) -> Bool+--   invariant (x, y, z, i) = x + (-z) + i > (-1) && x + (-z) + i < 1 && x + y + (-z) > (-1)+--+-- This is a bit hard to read, but you can convince yourself it is equivalent to @x + i .== z .&& x + y .>= z@:+--+-- >>> let f (x, y, z, i) = x + (-z) + i .> (-1) .&& x + (-z) + i .< 1 .&& x + y + (-z) .> (-1)+-- >>> let g (x, y, z, i) = x + i .== z .&& x + y .>= z+-- >>> f === (g :: Inv)+-- Q.E.D.+synthesize :: IO SatResult+synthesize = sat vcs+  where invariant :: Inv+        invariant = uninterpretWithArgs "invariant" ["x", "y", "z", "i"]++        vcs :: ConstraintSet+        vcs = do setLogic $ CustomLogic "HORN"+                 constrain $ vc1 invariant+                 constrain $ vc2 invariant+                 constrain $ vc3 invariant++-- | Verify that the synthesized function does indeed work. To do so, we simply prove that the invariant found satisfies all the vcs:+--+-- >>> verify+-- Q.E.D.+verify :: IO ThmResult+verify = prove vcs+  where invariant :: Inv+        invariant (x, y, z, i) = x + (-z) + i .> (-1) .&& x + (-z) + i .< 1 .&& x + y + (-z) .> (-1)++        vcs :: SBool+        vcs =   quantifiedBool (vc1 invariant)+            .&& quantifiedBool (vc3 invariant)+            .&& quantifiedBool (vc3 invariant)++{- HLint ignore quantify "Redundant lambda" -}
Documentation/SBV/Examples/Puzzles/Coins.hs view
@@ -94,12 +94,15 @@ puzzle :: IO SatResult puzzle = sat $ do         cs <- mapM mkCoin [1..6]+         -- Assert each of the constraints for all combinations that has         -- at least two coins (to make change)         mapM_ constrain [c s | s <- combinations cs, length s >= 2, c <- [c1, c2, c3, c4, c5, c6]]+         -- the following constraint is not necessary for solving the puzzle         -- however, it makes sure that the solution comes in decreasing value of coins,         -- thus allowing the above test to succeed regardless of the solver used.-        constrain $ sAnd $ zipWith (.>=) cs (tail cs)+        constrain $ sAnd $ zipWith (.>=) cs (drop 1 cs)+         -- assert that the sum must be 115 cents.         return $ sum cs .== 115
Documentation/SBV/Examples/Puzzles/HexPuzzle.hs view
@@ -78,7 +78,7 @@          $ ite (b .== 15)                        (rot [10, 11, 16, 19, 18, 14]) g   where rot xs = foldr (\(i, c) a -> writeArray a (literal i) c) g (zip new cur)           where cur = map (readArray g . literal) xs-                new = tail xs ++ [head xs]+                new = drop 1 xs ++ take 1 xs  -- | Iteratively search at increasing depths of button-presses to see if we can -- transform from the initial board position to a final board position.
Documentation/SBV/Examples/Puzzles/MagicSquare.hs view
@@ -34,7 +34,7 @@  -- | Get the diagonal of a square matrix diag :: [[a]] -> [a]-diag ((a:_):rs) = a : diag (map tail rs)+diag ((a:_):rs) = a : diag (map (drop 1) rs) diag _          = []  -- | Test if a given board is a magic square
+ Documentation/SBV/Examples/Puzzles/Newspaper.hs view
@@ -0,0 +1,104 @@+-----------------------------------------------------------------------------+-- |+-- Module    : Documentation.SBV.Examples.Puzzles.Newspaper+-- Copyright : (c) Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Solution to the following puzzle (found at <http://hugopeters.me/posts/15>)+-- which contains 10 questions:+--+-- @+-- a. What is sum of all integer answers?+-- b. How many boolean answers are true?+-- c. Is a the largest number?+-- d. How many integers are equal to me?+-- e. Are all integers positive?+-- f. What is the average of all integers?+-- g. Is d strictly larger than b?+-- h. What is a / h?+-- i. Is f equal to d - b - h * d?+-- j. What is the answer to this question?+-- @+--+-- Note that @j@ is ambiguous: It can be a boolean or an integer. We use+-- the solver to decide what its type should be, so that all the other+-- answers are consistent with that decision.+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror #-}++module Documentation.SBV.Examples.Puzzles.Newspaper where++import Data.SBV+import Data.SBV.Either++-- | Encoding of the constraints.+puzzle :: Symbolic ()+puzzle = do+    a <- sInteger "a"+    b <- sInteger "b"+    c <- sBool    "c"+    d <- sInteger "d"+    e <- sBool    "e"+    f <- sInteger "f"+    g <- sBool    "g"+    h <- sInteger "h"+    i <- sBool    "i"+    j <- sEither  "j"++    jIsInt <- sBool "jIsInt"++    let ints  intj = [a, b, d, f, h] ++ [fromRight j |     intj]+        bools intj = [c, e, g, i]    ++ [fromLeft  j | not intj]++        choice fn = ite jIsInt (fn True) (fn False)++    -- a. What is sum of all integer answers?+    constrain $ a .== choice (sum . ints)++    -- b. How many boolean answers are true?+    constrain $ b .== choice (sum . map oneIf . bools)++    -- c. Is a the largest number?+    constrain $ c .== (a .== choice (foldr1 smax . ints))++    -- d. How many integers are equal to me?+    constrain $ d .== choice (sum . map (oneIf . (d .==)) . ints)++    -- e. Are all integers positive?+    constrain $ e .== choice (sAll (.> 0) . ints)++    -- f. What is the average of all integers?+    constrain $ f * choice (literal . toInteger . length . ints) .== choice (sum . ints)++    -- g. is d strictly larger than b?+    constrain $ g .== (d .> b)++    -- h. what is a / h?+    constrain $ h * h .== a++    -- i. is f equal to d - b - h * d?+    constrain $ i .== (f .== d - b - h * d)++    -- j. what is the answer to this question?+    constrain $ ite jIsInt (isRight j) (isLeft j)++-- | Print all solutions to the problem. We have:+--+-- >>> solvePuzzle+-- Solution #1:+--   a =         144 :: Integer+--   b =           2 :: Integer+--   c =        True :: Bool+--   d =           2 :: Integer+--   e =       False :: Bool+--   f =          24 :: Integer+--   g =       False :: Bool+--   h =         -12 :: Integer+--   i =        True :: Bool+--   j = Right (-16) :: Either Bool Integer+-- This is the only solution.+solvePuzzle :: IO ()+solvePuzzle = print =<< allSatWith z3{isNonModelVar = (== "jIsInt")} puzzle
Documentation/SBV/Examples/Queries/Abducts.hs view
@@ -22,10 +22,10 @@ -- and we want to make @x + y >= 2@. We have: -- -- >>> example--- Got: (define-fun abd () Bool (= s1 2))--- Got: (define-fun abd () Bool (<= 2 s1))--- Got: (define-fun abd () Bool (= (+ s1 s0) 2))--- Got: (define-fun abd () Bool (= (+ s0 2) s1))+-- Got: (define-fun abd () Bool (and (= s0 s1) (= s0 1)))+-- Got: (define-fun abd () Bool (and (= 2 s1) (= s0 1)))+-- Got: (define-fun abd () Bool (and (= s0 s1) (<= 1 s1)))+-- Got: (define-fun abd () Bool (= 2 s1)) -- -- Note that @s0@ refers to @x@ and @s1@ refers to @y@ above. You can verify -- that adding any of these will ensure @x + y >= 2@.
Documentation/SBV/Examples/Queries/FourFours.hs view
@@ -85,7 +85,7 @@                        t1            <- trees left                        t2            <- trees right                        trees [B () t1 t2]-          where splits = init $ tail $ zip (inits xs) (tails xs)+          where splits = init $ drop 1 $ zip (inits xs) (tails xs)  -- | Given a tree with hols, fill it with symbolic operators. This is the /trick/ that allows -- us to consider only 640 trees as opposed to over 10 million.
Documentation/SBV/Examples/Queries/Interpolants.hs view
@@ -96,25 +96,25 @@ -- of @y@, which is the only common symbol among them. We have: -- -- >>> runSMT evenOdd--- "(or (= s1 0) (= s1 (* 2 (div s1 2))))"+-- "(let (a!1 (= (mod (+ (* (- 1) s1) 0) 2) 0)) (or (= s1 0) a!1))" -- -- This is a bit hard to read unfortunately, due to translation artifacts and use of strings. To analyze, -- we need to know that @s1@ is @y@ through SBV's translation. Let's express it in--- regular infix notation with @y@ for @s1@:+-- regular infix notation with @y@ for @s1@, and substitute the let-bound variable: ----- @(y == 0) || (y == 2 * (y `div` 2))@+-- @(y == 0) || ((-y) `mod` 2 == 0)@ -- -- Notice that the only symbol is @y@, as required. To establish that this is -- indeed an interpolant, we should establish that when @y@ is even, this formula -- is @True@; and if @y@ is odd, then it should be @False@. You can argue--- mathematically that this indeed the case, but let's just use SBV to prove these:+-- mathematically that this indeed the case, but let's just use SBV to prove the required relationships: ----- >>> prove $ \y -> (y `sMod` 2 .== 0) .=> ((y .== 0) .|| (y .== 2 * (y `sDiv` (2::SInteger))))+-- >>> prove $ \(y :: SInteger) -> (y `sMod` 2 .== 0) .=> ((y .== 0) .|| ((-y) `sMod` 2 .== 0)) -- Q.E.D. -- -- And: ----- >>> prove $ \y -> (y `sMod` 2 .== 1) .=> sNot ((y .== 0) .|| (y .== 2 * (y `sDiv` (2::SInteger))))+-- >>> prove $ \(y :: SInteger) -> (y `sMod` 2 .== 1) .=> sNot ((y .== 0) .|| ((-y) `sMod` 2 .== 0)) -- Q.E.D. -- -- This establishes that we indeed have an interpolant!
Documentation/SBV/Examples/Uninterpreted/Multiply.hs view
@@ -47,10 +47,10 @@ -- >>> sat synthMul22 -- Satisfiable. Model: --   mul22_hi :: Bool -> Bool -> Bool -> Bool -> Bool---   mul22_hi True  False False True  = True---   mul22_hi True  True  False True  = True --   mul22_hi False True  True  True  = True+--   mul22_hi True  True  False True  = True --   mul22_hi True  False True  True  = True+--   mul22_hi True  False False True  = True --   mul22_hi False True  True  False = True --   mul22_hi True  True  True  False = True --   mul22_hi _     _     _     _     = False@@ -67,10 +67,10 @@ -- -- >>> :{ -- mul22_hi :: (SBool, SBool, SBool, SBool) -> SBool--- mul22_hi params = params `sElem` [ (sTrue,  sFalse, sFalse, sTrue)+-- mul22_hi params = params `sElem` [ (sFalse, sTrue,  sTrue,  sTrue) --                                  , (sTrue,  sTrue,  sFalse, sTrue)---                                  , (sFalse, sTrue,  sTrue,  sTrue) --                                  , (sTrue,  sFalse, sTrue,  sTrue)+--                                  , (sTrue,  sFalse, sFalse, sTrue) --                                  , (sFalse, sTrue,  sTrue,  sFalse) --                                  , (sTrue,  sTrue,  sTrue,  sFalse) --                                  ]
Documentation/SBV/Examples/WeakestPreconditions/Sum.hs view
@@ -205,8 +205,8 @@ Following proof obligation failed: ==================================   Invariant for loop "i < n" is not maintained by the body:-    Before: SumS {n = 2, i = 1, s = 1}-    After : SumS {n = 2, i = 2, s = 3}+    Before: SumS {n = 3, i = 1, s = 1}+    After : SumS {n = 3, i = 2, s = 3}  Here, we posed the extra incorrect invariant that @s <= i@ must be maintained, and SBV found us a reachable state that violates the invariant. The /before/ state indeed satisfies @s <= i@, but the /after/ state does not. Note that the proof fails in this case not because the program
INSTALL view
@@ -4,7 +4,7 @@      cabal install sbv  SBV relies on an external SMT solver to be installed. We currently support-ABC, Boolector, Bitwuzla, CVC4, CVC5, MathSAT, Yices, and Z3. We recommend installing the+ABC, Boolector, Bitwuzla, CVC4, CVC5, DReal, MathSAT, OpenSMT, Yices, and Z3. We recommend installing the freely available z3 SMT solver from Microsoft, the default solver used by SBV. You can get it from <http://github.com/Z3Prover/z3>.
LICENSE view
@@ -1,6 +1,6 @@ SBV: SMT Based Verification in Haskell -Copyright (c) 2010-2023, Levent Erkok (erkokl@gmail.com)+Copyright (c) 2010-2024, Levent Erkok (erkokl@gmail.com) All rights reserved.  Redistribution and use in source and binary forms, with or without
− SBVBenchSuite/BenchSuite/BitPrecise/MultMask.hs 
@@ -1,31 +0,0 @@--------------------------------------------------------------------------------- |--- Module    : BenchSuite.BitPrecise.MultMask--- Copyright : (c) Jeffrey Young---                 Levent Erkok--- License   : BSD3--- Maintainer: erkokl@gmail.com--- Stability : experimental------ Bench suite for Documentation.SBV.Examples.BitPrecise.MultMask--------------------------------------------------------------------------------{-# OPTIONS_GHC -Wall -Werror #-}--module BenchSuite.BitPrecise.MultMask(benchmarks) where--import BenchSuite.Bench.Bench as B--import Data.SBV---- benchmark suite-benchmarks :: Runner-benchmarks = rGroup-  [ B.runWith conf "MultMask" find-  ]-  where find = do mask <- free "mask"-                  mult <- free "mult"-                  constrain $ \(Forall inp) ->-                        let res = (mask .&. inp) * (mult :: SWord64)-                        in inp `sExtractBits` [7, 15 .. 63] .== res `sExtractBits` [56 .. 63]-        conf = z3{printBase=16, satCmd = "(check-sat-using (and-then simplify smtfd))"}
− SBVBenchSuite/BenchSuite/Existentials/CRCPolynomial.hs 
@@ -1,23 +0,0 @@--------------------------------------------------------------------------------- |--- Module    : BenchSuite.Existentials.CRCPolynomial--- Copyright : (c) Jeffrey Young---                 Levent Erkok--- License   : BSD3--- Maintainer: erkokl@gmail.com--- Stability : experimental------ Bench suite for Documentation.SBV.Examples.Existentials.CRCPolynomial--------------------------------------------------------------------------------{-# OPTIONS_GHC -Wall -Werror #-}--module BenchSuite.Existentials.CRCPolynomial(benchmarks) where--import Documentation.SBV.Examples.Existentials.CRCPolynomial--import BenchSuite.Bench.Bench---- benchmark suite-benchmarks :: Runner-benchmarks =  runIO "FindPolynomials" (findHD4Polynomials 5)
− SBVBenchSuite/BenchSuite/Lists/Nested.hs 
@@ -1,25 +0,0 @@--------------------------------------------------------------------------------- |--- Module    : BenchSuite.Lists.Nested--- Copyright : (c) Jeffrey Young---                 Levent Erkok--- License   : BSD3--- Maintainer: erkokl@gmail.com--- Stability : experimental------ Bench suite for Documentation.SBV.Examples.Lists.Nested--------------------------------------------------------------------------------{-# OPTIONS_GHC -Wall -Werror #-}--module BenchSuite.Lists.Nested(benchmarks) where--import Documentation.SBV.Examples.Lists.Nested--import BenchSuite.Bench.Bench---- benchmark suite-benchmarks :: Runner-benchmarks = rGroup-             [ runIO "Nested.Example" nestedExample-             ]
SBVBenchSuite/BenchSuite/Puzzles/Coins.hs view
@@ -25,7 +25,7 @@ benchmarks = rGroup [ S.run "Coins" coinsPgm ]   where coinsPgm = do cs <- mapM mkCoin [1..6]                       mapM_ constrain [c s | s <- combinations cs, length s >= 2, c <- [c1, c2, c3, c4, c5, c6]]-                      constrain $ sAnd $ zipWith (.>=) cs (tail cs)+                      constrain $ sAnd $ zipWith (.>=) cs (drop 1 cs)                       -- normally we would call output here, but returning                       -- several outputs from a symbolic computation doesn't                       -- play nice with either the transcript generation or the benchmarking apparently
SBVBenchSuite/SBVBench.hs view
@@ -38,7 +38,7 @@ -- import qualified BenchSuite.BitPrecise.BrokenSearch -- import qualified BenchSuite.BitPrecise.Legato -- import qualified BenchSuite.BitPrecise.MergeSort-import qualified BenchSuite.BitPrecise.MultMask+-- import qualified BenchSuite.BitPrecise.MultMask -- import qualified BenchSuite.BitPrecise.PrefixSum  -- Queries@@ -111,14 +111,13 @@ -- 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.CRCPolynomial import qualified BenchSuite.Existentials.Diophantine  -- Transformers@@ -208,7 +207,7 @@                        -- , BenchSuite.BitPrecise.BrokenSearch.benchmarks                        -- , BenchSuite.BitPrecise.Legato.benchmarks                        -- , BenchSuite.BitPrecise.MergeSort.benchmarks-                       , BenchSuite.BitPrecise.MultMask.benchmarks+                       -- , BenchSuite.BitPrecise.MultMask.benchmarks                        -- expensive                        -- , BenchSuite.BitPrecise.PrefixSum.benchmarks                        ]@@ -342,7 +341,6 @@ listBenchmarks :: [Runner] listBenchmarks = [ BenchSuite.Lists.BoundedMutex.benchmarks                  , BenchSuite.Lists.Fibonacci.benchmarks-                 , BenchSuite.Lists.Nested.benchmarks                  ]  lists :: Benchmark@@ -361,8 +359,8 @@  --------------------------- Existentials ---------------------------------------- existentialBenchmarks :: [Runner]-existentialBenchmarks = [ BenchSuite.Existentials.CRCPolynomial.benchmarks-                        , BenchSuite.Existentials.Diophantine.benchmarks+existentialBenchmarks = [ -- BenchSuite.Existentials.CRCPolynomial.benchmarks+                          BenchSuite.Existentials.Diophantine.benchmarks                         ]  existentials :: Benchmark
SBVBenchSuite/Utils/SBVBenchFramework.hs view
@@ -88,7 +88,7 @@     is :: [Int]     is = L.elemIndices e nm -    chunks = [(a, tail b) | (a, b) <- fmap (`L.splitAt` nm) is]+    chunks = [(a, drop 1 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@@ -96,7 +96,7 @@ -- the assumptions of the bench-show package, thus we define a specialty -- classifier to handle the overhead case overheadClassifier :: Char -> String -> Maybe (String, String)-overheadClassifier e nm = Just $ last $ fmap (\(a,b) -> (tail b, a)) chunks+overheadClassifier e nm = Just $ last $ fmap (\(a,b) -> (drop 1 b, a)) chunks   where     is :: [Int]     is = L.elemIndices e nm
SBVTestSuite/GoldFiles/allSat6.gold view
@@ -1,8 +1,8 @@ Solution #1:-  x = 0 :: Word8+  x = 1 :: Word8   y = 2 :: Word8 Solution #2:-  x = 1 :: Word8+  x = 0 :: Word8   y = 2 :: Word8 Solution #3:   x = 0 :: Word8
SBVTestSuite/GoldFiles/allSat7.gold view
@@ -85,34255 +85,34255 @@ [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] (define-fun s20 () Int 4)-[GOOD] (define-fun s21 () Bool (distinct s0 s20))-[GOOD] (assert s21)-Fast allSat, Looking for solution 5-[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] (define-fun s22 () Int 5)-[GOOD] (define-fun s23 () Bool (distinct s0 s22))-[GOOD] (assert s23)-Fast allSat, Looking for solution 6-[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] (define-fun s24 () Int 6)-[GOOD] (define-fun s25 () Bool (distinct s0 s24))-[GOOD] (assert s25)-Fast allSat, Looking for solution 7-[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] (define-fun s26 () Int 7)-[GOOD] (define-fun s27 () Bool (distinct s0 s26))-[GOOD] (assert s27)-Fast allSat, Looking for solution 8-[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] (define-fun s28 () Int 8)-[GOOD] (define-fun s29 () Bool (distinct s0 s28))-[GOOD] (assert s29)-Fast allSat, Looking for solution 9-[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] (define-fun s30 () Int 9)-[GOOD] (define-fun s31 () Bool (distinct s0 s30))-[GOOD] (assert s31)-Fast allSat, Looking for solution 10-[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] (define-fun s32 () Int 10)-[GOOD] (define-fun s33 () Bool (distinct s0 s32))-[GOOD] (assert s33)-Fast allSat, Looking for solution 11-[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] (define-fun s34 () Int 11)-[GOOD] (define-fun s35 () Bool (distinct s0 s34))-[GOOD] (assert s35)-Fast allSat, Looking for solution 12-[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] (define-fun s36 () Int 12)-[GOOD] (define-fun s37 () Bool (distinct s0 s36))-[GOOD] (assert s37)-Fast allSat, Looking for solution 13-[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] (define-fun s38 () Int 13)-[GOOD] (define-fun s39 () Bool (distinct s0 s38))-[GOOD] (assert s39)-Fast allSat, Looking for solution 14-[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] (define-fun s40 () Int 14)-[GOOD] (define-fun s41 () Bool (distinct s0 s40))-[GOOD] (assert s41)-Fast allSat, Looking for solution 15-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (define-fun s42 () Bool (distinct s0 s5))-[GOOD] (assert s42)-Fast allSat, Looking for solution 16-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (define-fun s43 () Bool (distinct s1 s3))-[GOOD] (assert s43)-[GOOD] (define-fun s44 () Bool (= s0 s5))-[GOOD] (assert s44)-Fast allSat, Looking for solution 16-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (define-fun s45 () Bool (distinct s1 s18))-[GOOD] (assert s45)-Fast allSat, Looking for solution 17-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (define-fun s46 () Bool (distinct s1 s16))-[GOOD] (assert s46)-Fast allSat, Looking for solution 18-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (define-fun s47 () Bool (distinct s1 s20))-[GOOD] (assert s47)-Fast allSat, Looking for solution 19-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (define-fun s48 () Bool (distinct s1 s22))-[GOOD] (assert s48)-Fast allSat, Looking for solution 20-[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] (define-fun s49 () Bool (distinct s1 s24))-[GOOD] (assert s49)-Fast allSat, Looking for solution 21-[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] (define-fun s50 () Bool (distinct s1 s26))-[GOOD] (assert s50)-Fast allSat, Looking for solution 22-[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] (define-fun s51 () Bool (distinct s1 s28))-[GOOD] (assert s51)-Fast allSat, Looking for solution 23-[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] (define-fun s52 () Bool (distinct s1 s30))-[GOOD] (assert s52)-Fast allSat, Looking for solution 24-[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] (define-fun s53 () Bool (distinct s1 s32))-[GOOD] (assert s53)-Fast allSat, Looking for solution 25-[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] (define-fun s54 () Bool (distinct s1 s34))-[GOOD] (assert s54)-Fast allSat, Looking for solution 26-[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] (define-fun s55 () Bool (distinct s1 s36))-[GOOD] (assert s55)-Fast allSat, Looking for solution 27-[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] (define-fun s56 () Bool (distinct s1 s38))-[GOOD] (assert s56)-Fast allSat, Looking for solution 28-[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 13))-[GOOD] (push 1)-[GOOD] (define-fun s57 () Bool (distinct s1 s40))-[GOOD] (assert s57)-Fast allSat, Looking for solution 29-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (define-fun s58 () Bool (distinct s2 s38))-[GOOD] (assert s58)-[GOOD] (define-fun s59 () Bool (= s1 s40))-[GOOD] (assert s59)-Fast allSat, Looking for solution 29-[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] (define-fun s60 () Bool (distinct s2 s36))-[GOOD] (assert s60)-Fast allSat, Looking for solution 30-[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] (define-fun s61 () Bool (distinct s2 s34))-[GOOD] (assert s61)-Fast allSat, Looking for solution 31-[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] (define-fun s62 () Bool (distinct s2 s32))-[GOOD] (assert s62)-Fast allSat, Looking for solution 32-[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] (define-fun s63 () Bool (distinct s2 s30))-[GOOD] (assert s63)-Fast allSat, Looking for solution 33-[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] (define-fun s64 () Bool (distinct s2 s28))-[GOOD] (assert s64)-Fast allSat, Looking for solution 34-[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] (define-fun s65 () Bool (distinct s2 s26))-[GOOD] (assert s65)-Fast allSat, Looking for solution 35-[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] (define-fun s66 () Bool (distinct s2 s24))-[GOOD] (assert s66)-Fast allSat, Looking for solution 36-[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] (define-fun s67 () Bool (distinct s2 s22))-[GOOD] (assert s67)-Fast allSat, Looking for solution 37-[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] (define-fun s68 () Bool (distinct s2 s20))-[GOOD] (assert s68)-Fast allSat, Looking for solution 38-[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] (define-fun s69 () Bool (distinct s2 s16))-[GOOD] (assert s69)-Fast allSat, Looking for solution 39-[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] (define-fun s70 () Bool (distinct s2 s18))-[GOOD] (assert s70)-Fast allSat, Looking for solution 40-[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] (define-fun s71 () Bool (distinct s2 s3))-[GOOD] (assert s71)-Fast allSat, Looking for solution 41-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (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 s72 () Bool (distinct s2 s40))-[GOOD] (assert s72)-[GOOD] (define-fun s73 () Bool (= s1 s38))-[GOOD] (assert s73)-Fast allSat, Looking for solution 41-[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 s71)-Fast allSat, Looking for solution 42-[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 s70)-Fast allSat, Looking for solution 43-[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 s69)-Fast allSat, Looking for solution 44-[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 s68)-Fast allSat, Looking for solution 45-[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 s67)-Fast allSat, Looking for solution 46-[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 s66)-Fast allSat, Looking for solution 47-[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 s65)-Fast allSat, Looking for solution 48-[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 s64)-Fast allSat, Looking for solution 49-[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 s63)-Fast allSat, Looking for solution 50-[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 s62)-Fast allSat, Looking for solution 51-[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 s61)-Fast allSat, Looking for solution 52-[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 12))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 53-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 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] (define-fun s74 () Bool (= s1 s36))-[GOOD] (assert s74)-Fast allSat, Looking for solution 53-[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 11))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 54-[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 s62)-Fast allSat, Looking for solution 55-[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 s63)-Fast allSat, Looking for solution 56-[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 s64)-Fast allSat, Looking for solution 57-[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 s65)-Fast allSat, Looking for solution 58-[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 s66)-Fast allSat, Looking for solution 59-[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 s67)-Fast allSat, Looking for solution 60-[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 s68)-Fast allSat, Looking for solution 61-[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 s69)-Fast allSat, Looking for solution 62-[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 s70)-Fast allSat, Looking for solution 63-[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 s71)-Fast allSat, Looking for solution 64-[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 s58)-Fast allSat, Looking for solution 65-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 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] (define-fun s75 () Bool (= s1 s34))-[GOOD] (assert s75)-Fast allSat, Looking for solution 65-[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 s58)-Fast allSat, Looking for solution 66-[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 s60)-Fast allSat, Looking for solution 67-[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 10))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 68-[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 s63)-Fast allSat, Looking for solution 69-[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 s64)-Fast allSat, Looking for solution 70-[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 s65)-Fast allSat, Looking for solution 71-[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 s66)-Fast allSat, Looking for solution 72-[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 s67)-Fast allSat, Looking for solution 73-[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 s68)-Fast allSat, Looking for solution 74-[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 s69)-Fast allSat, Looking for solution 75-[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 s70)-Fast allSat, Looking for solution 76-[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 s71)-Fast allSat, Looking for solution 77-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 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] (define-fun s76 () Bool (= s1 s32))-[GOOD] (assert s76)-Fast allSat, Looking for solution 77-[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 9))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 78-[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 s64)-Fast allSat, Looking for solution 79-[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 s65)-Fast allSat, Looking for solution 80-[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 s66)-Fast allSat, Looking for solution 81-[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 s67)-Fast allSat, Looking for solution 82-[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 s68)-Fast allSat, Looking for solution 83-[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 s69)-Fast allSat, Looking for solution 84-[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 s70)-Fast allSat, Looking for solution 85-[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 s71)-Fast allSat, Looking for solution 86-[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 s61)-Fast allSat, Looking for solution 87-[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 s60)-Fast allSat, Looking for solution 88-[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 s58)-Fast allSat, Looking for solution 89-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 1)-[GOOD] (pop 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] (define-fun s77 () Bool (= s1 s30))-[GOOD] (assert s77)-Fast allSat, Looking for solution 89-[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 s58)-Fast allSat, Looking for solution 90-[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 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 9))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 92-[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 s62)-Fast allSat, Looking for solution 93-[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 8))-[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 9))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[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 9))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[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 9))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[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 9))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[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 9))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[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 9))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[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 9))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[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 s72)-[GOOD] (define-fun s78 () Bool (= s1 s28))-[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 8))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 102-[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 s66)-Fast allSat, Looking for solution 103-[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 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 8))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[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 8))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[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 8))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[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 8))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[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 8))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 109-[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 s62)-Fast allSat, Looking for solution 110-[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 s61)-Fast allSat, Looking for solution 111-[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 s60)-Fast allSat, Looking for solution 112-[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 s58)-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 s72)-[GOOD] (define-fun s79 () Bool (= s1 s26))-[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 7))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 114-[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 s60)-Fast allSat, Looking for solution 115-[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 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 7))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 117-[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 s63)-Fast allSat, Looking for solution 118-[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 s64)-Fast allSat, Looking for solution 119-[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 6))-[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 7))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[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 7))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[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 7))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[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 7))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[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 7))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[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 s72)-[GOOD] (define-fun s80 () Bool (= s1 s24))-[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 6))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 126-[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 s68)-Fast allSat, Looking for solution 127-[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 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 6))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[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 6))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[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 6))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 131-[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 s64)-Fast allSat, Looking for solution 132-[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 s63)-Fast allSat, Looking for solution 133-[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 s62)-Fast allSat, Looking for solution 134-[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 s61)-Fast allSat, Looking for solution 135-[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 s60)-Fast allSat, Looking for solution 136-[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 s58)-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 s72)-[GOOD] (define-fun s81 () Bool (= s1 s22))-[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 5))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 138-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 139-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 140-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[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 5))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 142-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[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 5))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 144-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 145-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 5))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[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 5))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[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 5))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[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 5))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[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 s72)-[GOOD] (define-fun s82 () Bool (= s1 s20))-[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 4))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[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 4))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[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 4))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[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 4))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 153-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 154-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 155-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[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 4))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 157-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 158-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 159-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 160-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 4))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s58)-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 s72)-[GOOD] (define-fun s83 () Bool (= s1 s16))-[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 3))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 162-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[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 3))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 164-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 165-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 166-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 167-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 168-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 169-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 170-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 171-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[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 3))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[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 s72)-[GOOD] (define-fun s84 () Bool (= s1 s18))-[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 2))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 174-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 175-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 176-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 177-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 178-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 179-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[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 2))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 181-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 182-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 183-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 184-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s58)-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 s72)-[GOOD] (assert s44)-[GOOD] (define-fun s85 () Bool (= s1 s3))-[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 1))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 186-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 187-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 188-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 189-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 190-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[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 1))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 192-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 193-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 194-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 195-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 196-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (s0))-[RECV] ((s0 15))-[SEND] (get-value (s1))-[RECV] ((s1 1))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s70)-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] (assert s43)-[GOOD] (define-fun s86 () Bool (= s0 s40))-[GOOD] (assert s86)-Fast allSat, Looking for solution 197-[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 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 3))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[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 4))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[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 5))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[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 6))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[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 7))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[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 8))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[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 9))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[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 10))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[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 11))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[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 12))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[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 13))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[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 15))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (define-fun s87 () Bool (distinct s1 s5))-[GOOD] (assert s87)-Fast allSat, Looking for solution 210-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s58)-[GOOD] (define-fun s88 () Bool (= s1 s5))-[GOOD] (assert s88)-Fast allSat, Looking for solution 210-[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 s60)-Fast allSat, Looking for solution 211-[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 s61)-Fast allSat, Looking for solution 212-[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 s62)-Fast allSat, Looking for solution 213-[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 s63)-Fast allSat, Looking for solution 214-[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 s64)-Fast allSat, Looking for solution 215-[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 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 15))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 217-[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 s67)-Fast allSat, Looking for solution 218-[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 s68)-Fast allSat, Looking for solution 219-[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 s69)-Fast allSat, Looking for solution 220-[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 s70)-Fast allSat, Looking for solution 221-[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 s71)-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] (define-fun s89 () Bool (distinct s2 s5))-[GOOD] (assert s89)-[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 13))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 223-[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 s61)-Fast allSat, Looking for solution 224-[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 s62)-Fast allSat, Looking for solution 225-[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 s63)-Fast allSat, Looking for solution 226-[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 s64)-Fast allSat, Looking for solution 227-[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 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 13))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 229-[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 s67)-Fast allSat, Looking for solution 230-[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 s68)-Fast allSat, Looking for solution 231-[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 s69)-Fast allSat, Looking for solution 232-[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 s70)-Fast allSat, Looking for solution 233-[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 s71)-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 s58)-[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 12))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 235-[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 s62)-Fast allSat, Looking for solution 236-[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 s63)-Fast allSat, Looking for solution 237-[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 s64)-Fast allSat, Looking for solution 238-[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 s65)-Fast allSat, Looking for solution 239-[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 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 12))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 241-[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 s68)-Fast allSat, Looking for solution 242-[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 s69)-Fast allSat, Looking for solution 243-[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 s70)-Fast allSat, Looking for solution 244-[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 s71)-Fast allSat, Looking for solution 245-[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 s89)-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 s60)-[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 11))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s89)-Fast allSat, Looking for solution 247-[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 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 11))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 249-[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 s63)-Fast allSat, Looking for solution 250-[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 s64)-Fast allSat, Looking for solution 251-[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 s65)-Fast allSat, Looking for solution 252-[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 s66)-Fast allSat, Looking for solution 253-[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 s67)-Fast allSat, Looking for solution 254-[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 s68)-Fast allSat, Looking for solution 255-[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 s69)-Fast allSat, Looking for solution 256-[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 s70)-Fast allSat, Looking for solution 257-[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 s71)-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 s61)-[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 10))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[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 10))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[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 10))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[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 10))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[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 10))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[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 10))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[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 10))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[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 10))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 266-[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 s71)-Fast allSat, Looking for solution 267-[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 s60)-Fast allSat, Looking for solution 268-[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 s58)-Fast allSat, Looking for solution 269-[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 s89)-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 s62)-[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 9))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s89)-Fast allSat, Looking for solution 271-[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 s58)-Fast allSat, Looking for solution 272-[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 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 9))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 274-[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 s64)-Fast allSat, Looking for solution 275-[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 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 9))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 277-[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 s67)-Fast allSat, Looking for solution 278-[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 s68)-Fast allSat, Looking for solution 279-[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 s69)-Fast allSat, Looking for solution 280-[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 s70)-Fast allSat, Looking for solution 281-[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 s71)-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 s63)-[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 8))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 283-[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 s66)-Fast allSat, Looking for solution 284-[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 s67)-Fast allSat, Looking for solution 285-[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 s68)-Fast allSat, Looking for solution 286-[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 s69)-Fast allSat, Looking for solution 287-[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 s70)-Fast allSat, Looking for solution 288-[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 s71)-Fast allSat, Looking for solution 289-[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 s62)-Fast allSat, Looking for solution 290-[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 s61)-Fast allSat, Looking for solution 291-[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 s60)-Fast allSat, Looking for solution 292-[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 s58)-Fast allSat, Looking for solution 293-[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 s89)-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 s64)-[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 7))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s89)-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 13))-[GOOD] (push 1)-[GOOD] (assert s58)-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 12))-[GOOD] (push 1)-[GOOD] (assert s60)-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 11))-[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 7))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s62)-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 9))-[GOOD] (push 1)-[GOOD] (assert s63)-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 s66)-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 s67)-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 s68)-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 s69)-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 s70)-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 s71)-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 s65)-[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 6))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 307-[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 s68)-Fast allSat, Looking for solution 308-[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 s69)-Fast allSat, Looking for solution 309-[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 s70)-Fast allSat, Looking for solution 310-[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 s71)-Fast allSat, Looking for solution 311-[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 s64)-Fast allSat, Looking for solution 312-[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 s63)-Fast allSat, Looking for solution 313-[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 s62)-Fast allSat, Looking for solution 314-[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 s61)-Fast allSat, Looking for solution 315-[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 s60)-Fast allSat, Looking for solution 316-[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 s58)-Fast allSat, Looking for solution 317-[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 s89)-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 s66)-[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 5))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s89)-Fast allSat, Looking for solution 319-[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 s58)-Fast allSat, Looking for solution 320-[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 s60)-Fast allSat, Looking for solution 321-[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 s61)-Fast allSat, Looking for solution 322-[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 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 5))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 324-[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 s64)-Fast allSat, Looking for solution 325-[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 s65)-Fast allSat, Looking for solution 326-[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 s68)-Fast allSat, Looking for solution 327-[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 s69)-Fast allSat, Looking for solution 328-[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 s70)-Fast allSat, Looking for solution 329-[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 s71)-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 s67)-[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 4))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 331-[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 s70)-Fast allSat, Looking for solution 332-[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 s71)-Fast allSat, Looking for solution 333-[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 s66)-Fast allSat, Looking for solution 334-[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 s65)-Fast allSat, Looking for solution 335-[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 s64)-Fast allSat, Looking for solution 336-[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 s63)-Fast allSat, Looking for solution 337-[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 s62)-Fast allSat, Looking for solution 338-[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 s61)-Fast allSat, Looking for solution 339-[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 s60)-Fast allSat, Looking for solution 340-[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 s58)-Fast allSat, Looking for solution 341-[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 s89)-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 s68)-[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 3))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s89)-Fast allSat, Looking for solution 343-[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 s58)-Fast allSat, Looking for solution 344-[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 s60)-Fast allSat, Looking for solution 345-[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 s61)-Fast allSat, Looking for solution 346-[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 s62)-Fast allSat, Looking for solution 347-[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 s63)-Fast allSat, Looking for solution 348-[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 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 3))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 350-[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 s66)-Fast allSat, Looking for solution 351-[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 s67)-Fast allSat, Looking for solution 352-[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 s70)-Fast allSat, Looking for solution 353-[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 s71)-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 s69)-[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 2))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 355-[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 s68)-Fast allSat, Looking for solution 356-[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 s67)-Fast allSat, Looking for solution 357-[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 s66)-Fast allSat, Looking for solution 358-[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 s65)-Fast allSat, Looking for solution 359-[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 s64)-Fast allSat, Looking for solution 360-[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 s63)-Fast allSat, Looking for solution 361-[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 s62)-Fast allSat, Looking for solution 362-[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 s61)-Fast allSat, Looking for solution 363-[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 s60)-Fast allSat, Looking for solution 364-[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 s58)-Fast allSat, Looking for solution 365-[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 s89)-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 s89)-[GOOD] (assert s86)-[GOOD] (assert s85)-Fast allSat, Looking for solution 366-[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 s58)-Fast allSat, Looking for solution 367-[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 s60)-Fast allSat, Looking for solution 368-[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 s61)-Fast allSat, Looking for solution 369-[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 s62)-Fast allSat, Looking for solution 370-[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 s63)-Fast allSat, Looking for solution 371-[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 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 1))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 373-[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 s66)-Fast allSat, Looking for solution 374-[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 s67)-Fast allSat, Looking for solution 375-[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 s68)-Fast allSat, Looking for solution 376-[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 s69)-Fast allSat, Looking for solution 377-[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 s70)-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 2))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s45)-Fast allSat, Looking for solution 379-[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 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 4))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[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 5))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[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 6))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[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 7))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[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 8))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[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 9))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[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 10))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[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 11))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[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 12))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[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 14))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s57)-Fast allSat, Looking for solution 390-[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 s87)-Fast allSat, Looking for solution 391-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s72)-[GOOD] (assert s88)-Fast allSat, Looking for solution 391-[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 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 15))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[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 15))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[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 15))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[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 15))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[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 15))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[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 15))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[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 15))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[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 15))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[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 15))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[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 15))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 402-[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 s71)-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 s89)-[GOOD] (assert s59)-Fast allSat, Looking for solution 403-[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 s60)-Fast allSat, Looking for solution 404-[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 s61)-Fast allSat, Looking for solution 405-[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 s62)-Fast allSat, Looking for solution 406-[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 s63)-Fast allSat, Looking for solution 407-[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 s64)-Fast allSat, Looking for solution 408-[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 s65)-Fast allSat, Looking for solution 409-[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 s66)-Fast allSat, Looking for solution 410-[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 s67)-Fast allSat, Looking for solution 411-[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 s68)-Fast allSat, Looking for solution 412-[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 s69)-Fast allSat, Looking for solution 413-[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 s70)-Fast allSat, Looking for solution 414-[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 s71)-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 12))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 416-[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 s62)-Fast allSat, Looking for solution 417-[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 s63)-Fast allSat, Looking for solution 418-[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 s64)-Fast allSat, Looking for solution 419-[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 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 12))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[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 12))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 422-[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 s68)-Fast allSat, Looking for solution 423-[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 s69)-Fast allSat, Looking for solution 424-[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 s70)-Fast allSat, Looking for solution 425-[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 s71)-Fast allSat, Looking for solution 426-[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 s89)-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 s60)-[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 11))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s89)-Fast allSat, Looking for solution 428-[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 s72)-Fast allSat, Looking for solution 429-[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 s62)-Fast allSat, Looking for solution 430-[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 s63)-Fast allSat, Looking for solution 431-[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 s64)-Fast allSat, Looking for solution 432-[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 s65)-Fast allSat, Looking for solution 433-[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 s66)-Fast allSat, Looking for solution 434-[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 s67)-Fast allSat, Looking for solution 435-[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 s68)-Fast allSat, Looking for solution 436-[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 s69)-Fast allSat, Looking for solution 437-[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 s70)-Fast allSat, Looking for solution 438-[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 s71)-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 s60)-[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 10))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 440-[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 s64)-Fast allSat, Looking for solution 441-[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 s65)-Fast allSat, Looking for solution 442-[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 s66)-Fast allSat, Looking for solution 443-[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 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 10))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 445-[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 s69)-Fast allSat, Looking for solution 446-[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 s70)-Fast allSat, Looking for solution 447-[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 s71)-Fast allSat, Looking for solution 448-[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 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 10))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 450-[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 s89)-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 s60)-[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 9))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 452-[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 s72)-Fast allSat, Looking for solution 453-[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 s89)-Fast allSat, Looking for solution 454-[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 s62)-Fast allSat, Looking for solution 455-[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 s64)-Fast allSat, Looking for solution 456-[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 s65)-Fast allSat, Looking for solution 457-[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 s66)-Fast allSat, Looking for solution 458-[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 s67)-Fast allSat, Looking for solution 459-[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 s68)-Fast allSat, Looking for solution 460-[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 s69)-Fast allSat, Looking for solution 461-[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 s70)-Fast allSat, Looking for solution 462-[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 s71)-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 s60)-[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 8))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[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 8))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[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 8))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[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 8))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[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 8))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[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 8))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 469-[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 s71)-Fast allSat, Looking for solution 470-[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 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 8))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[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 8))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[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 8))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 474-[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 s89)-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 s60)-[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 7))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 476-[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 s72)-Fast allSat, Looking for solution 477-[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 s89)-Fast allSat, Looking for solution 478-[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 s62)-Fast allSat, Looking for solution 479-[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 s63)-Fast allSat, Looking for solution 480-[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 s64)-Fast allSat, Looking for solution 481-[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 s66)-Fast allSat, Looking for solution 482-[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 s67)-Fast allSat, Looking for solution 483-[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 s68)-Fast allSat, Looking for solution 484-[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 s69)-Fast allSat, Looking for solution 485-[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 s70)-Fast allSat, Looking for solution 486-[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 s71)-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 s60)-[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 6))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[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 6))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[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 6))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[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 6))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 491-[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 s71)-Fast allSat, Looking for solution 492-[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 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 6))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[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 6))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[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 6))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[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 6))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[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 6))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 498-[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 s89)-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 s60)-[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 5))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s89)-Fast allSat, Looking for solution 500-[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 s72)-Fast allSat, Looking for solution 501-[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 s61)-Fast allSat, Looking for solution 502-[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 s62)-Fast allSat, Looking for solution 503-[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 s63)-Fast allSat, Looking for solution 504-[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 s64)-Fast allSat, Looking for solution 505-[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 s65)-Fast allSat, Looking for solution 506-[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 s66)-Fast allSat, Looking for solution 507-[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 s68)-Fast allSat, Looking for solution 508-[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 s69)-Fast allSat, Looking for solution 509-[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 s70)-Fast allSat, Looking for solution 510-[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 s71)-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 s60)-[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 4))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[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 4))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 513-[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 s71)-Fast allSat, Looking for solution 514-[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 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 4))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[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 4))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[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 4))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[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 4))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[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 4))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[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 4))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[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 4))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 522-[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 s89)-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 s60)-[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 3))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 524-[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 s72)-Fast allSat, Looking for solution 525-[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 s89)-Fast allSat, Looking for solution 526-[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 s62)-Fast allSat, Looking for solution 527-[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 s63)-Fast allSat, Looking for solution 528-[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 s64)-Fast allSat, Looking for solution 529-[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 s65)-Fast allSat, Looking for solution 530-[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 s66)-Fast allSat, Looking for solution 531-[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 s67)-Fast allSat, Looking for solution 532-[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 s68)-Fast allSat, Looking for solution 533-[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 s70)-Fast allSat, Looking for solution 534-[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 s71)-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 s60)-[GOOD] (assert s84)-Fast allSat, Looking for solution 535-[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 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 2))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[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 2))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[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 2))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[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 2))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[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 2))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[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 2))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[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 2))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[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 2))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[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 2))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[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 2))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 546-[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 s89)-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 s72)-[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 1))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s89)-Fast allSat, Looking for solution 548-[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 s60)-Fast allSat, Looking for solution 549-[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 s61)-Fast allSat, Looking for solution 550-[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 s62)-Fast allSat, Looking for solution 551-[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 s63)-Fast allSat, Looking for solution 552-[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 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 1))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 554-[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 s66)-Fast allSat, Looking for solution 555-[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 s67)-Fast allSat, Looking for solution 556-[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 s68)-Fast allSat, Looking for solution 557-[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 s69)-Fast allSat, Looking for solution 558-[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 s70)-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 s43)-[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 2))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s45)-Fast allSat, Looking for solution 560-[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 s46)-Fast allSat, Looking for solution 561-[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 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 5))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[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 6))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[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 7))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[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 8))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[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 9))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[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 10))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[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 11))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[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 13))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s56)-Fast allSat, Looking for solution 570-[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 s57)-Fast allSat, Looking for solution 571-[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 s87)-Fast allSat, Looking for solution 572-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s72)-[GOOD] (assert s88)-Fast allSat, Looking for solution 572-[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 s58)-Fast allSat, Looking for solution 573-[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 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 15))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[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 15))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[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 15))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[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 15))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[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 15))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[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 15))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[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 15))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[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 15))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 582-[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 s70)-Fast allSat, Looking for solution 583-[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 s71)-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 s89)-[GOOD] (assert s59)-Fast allSat, Looking for solution 584-[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 s61)-Fast allSat, Looking for solution 585-[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 s62)-Fast allSat, Looking for solution 586-[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 s63)-Fast allSat, Looking for solution 587-[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 s64)-Fast allSat, Looking for solution 588-[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 s65)-Fast allSat, Looking for solution 589-[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 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 14))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 591-[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 s68)-Fast allSat, Looking for solution 592-[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 s69)-Fast allSat, Looking for solution 593-[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 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 14))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[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 14))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s58)-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 s72)-[GOOD] (assert s73)-Fast allSat, Looking for solution 596-[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 s61)-Fast allSat, Looking for solution 597-[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 s62)-Fast allSat, Looking for solution 598-[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 s63)-Fast allSat, Looking for solution 599-[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 s64)-Fast allSat, Looking for solution 600-[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 s65)-Fast allSat, Looking for solution 601-[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 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 13))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 603-[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 s68)-Fast allSat, Looking for solution 604-[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 s69)-Fast allSat, Looking for solution 605-[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 s70)-Fast allSat, Looking for solution 606-[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 s71)-Fast allSat, Looking for solution 607-[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 s89)-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 s58)-[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 11))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s89)-Fast allSat, Looking for solution 609-[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 s72)-Fast allSat, Looking for solution 610-[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 s62)-Fast allSat, Looking for solution 611-[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 s63)-Fast allSat, Looking for solution 612-[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 s64)-Fast allSat, Looking for solution 613-[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 s65)-Fast allSat, Looking for solution 614-[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 s66)-Fast allSat, Looking for solution 615-[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 s67)-Fast allSat, Looking for solution 616-[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 s68)-Fast allSat, Looking for solution 617-[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 s69)-Fast allSat, Looking for solution 618-[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 s70)-Fast allSat, Looking for solution 619-[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 s71)-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 10))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[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 10))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[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 10))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[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 10))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[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 10))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[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 10))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[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 10))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 627-[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 s70)-Fast allSat, Looking for solution 628-[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 s71)-Fast allSat, Looking for solution 629-[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 s58)-Fast allSat, Looking for solution 630-[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 s72)-Fast allSat, Looking for solution 631-[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 s89)-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 s61)-[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 9))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 633-[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 s58)-Fast allSat, Looking for solution 634-[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 s72)-Fast allSat, Looking for solution 635-[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 s89)-Fast allSat, Looking for solution 636-[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 s64)-Fast allSat, Looking for solution 637-[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 s65)-Fast allSat, Looking for solution 638-[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 s66)-Fast allSat, Looking for solution 639-[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 s67)-Fast allSat, Looking for solution 640-[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 s68)-Fast allSat, Looking for solution 641-[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 s69)-Fast allSat, Looking for solution 642-[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 s70)-Fast allSat, Looking for solution 643-[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 s71)-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 s61)-[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 8))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[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 8))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[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 8))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[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 8))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[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 8))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 649-[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 s70)-Fast allSat, Looking for solution 650-[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 s71)-Fast allSat, Looking for solution 651-[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 s63)-Fast allSat, Looking for solution 652-[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 s62)-Fast allSat, Looking for solution 653-[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 s58)-Fast allSat, Looking for solution 654-[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 s72)-Fast allSat, Looking for solution 655-[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 s89)-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 s61)-[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 7))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 657-[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 s58)-Fast allSat, Looking for solution 658-[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 s72)-Fast allSat, Looking for solution 659-[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 s89)-Fast allSat, Looking for solution 660-[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 s63)-Fast allSat, Looking for solution 661-[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 s64)-Fast allSat, Looking for solution 662-[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 s66)-Fast allSat, Looking for solution 663-[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 s67)-Fast allSat, Looking for solution 664-[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 s68)-Fast allSat, Looking for solution 665-[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 s69)-Fast allSat, Looking for solution 666-[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 s70)-Fast allSat, Looking for solution 667-[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 s71)-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 s61)-[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 6))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[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 6))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[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 6))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 671-[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 s70)-Fast allSat, Looking for solution 672-[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 s71)-Fast allSat, Looking for solution 673-[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 s65)-Fast allSat, Looking for solution 674-[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 s64)-Fast allSat, Looking for solution 675-[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 s63)-Fast allSat, Looking for solution 676-[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 s62)-Fast allSat, Looking for solution 677-[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 s58)-Fast allSat, Looking for solution 678-[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 s72)-Fast allSat, Looking for solution 679-[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 s89)-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 s61)-[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 5))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s89)-Fast allSat, Looking for solution 681-[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 s72)-Fast allSat, Looking for solution 682-[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 s58)-Fast allSat, Looking for solution 683-[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 s62)-Fast allSat, Looking for solution 684-[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 s63)-Fast allSat, Looking for solution 685-[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 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 5))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 687-[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 s66)-Fast allSat, Looking for solution 688-[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 s68)-Fast allSat, Looking for solution 689-[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 s69)-Fast allSat, Looking for solution 690-[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 s70)-Fast allSat, Looking for solution 691-[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 s71)-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 s61)-[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 4))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 693-[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 s70)-Fast allSat, Looking for solution 694-[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 s71)-Fast allSat, Looking for solution 695-[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 s67)-Fast allSat, Looking for solution 696-[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 s66)-Fast allSat, Looking for solution 697-[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 s65)-Fast allSat, Looking for solution 698-[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 s64)-Fast allSat, Looking for solution 699-[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 s63)-Fast allSat, Looking for solution 700-[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 s62)-Fast allSat, Looking for solution 701-[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 s58)-Fast allSat, Looking for solution 702-[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 s72)-Fast allSat, Looking for solution 703-[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 s89)-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 s61)-[GOOD] (assert s83)-Fast allSat, Looking for solution 704-[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 s62)-Fast allSat, Looking for solution 705-[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 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 3))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 707-[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 s89)-Fast allSat, Looking for solution 708-[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 s63)-Fast allSat, Looking for solution 709-[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 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 3))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 711-[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 s66)-Fast allSat, Looking for solution 712-[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 s67)-Fast allSat, Looking for solution 713-[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 s68)-Fast allSat, Looking for solution 714-[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 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 3))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[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 s61)-[GOOD] (assert s84)-Fast allSat, Looking for solution 716-[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 s71)-Fast allSat, Looking for solution 717-[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 s69)-Fast allSat, Looking for solution 718-[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 s68)-Fast allSat, Looking for solution 719-[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 s67)-Fast allSat, Looking for solution 720-[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 s66)-Fast allSat, Looking for solution 721-[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 s65)-Fast allSat, Looking for solution 722-[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 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 2))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 724-[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 s62)-Fast allSat, Looking for solution 725-[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 s58)-Fast allSat, Looking for solution 726-[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 s72)-Fast allSat, Looking for solution 727-[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 s89)-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 s58)-[GOOD] (assert s91)-[GOOD] (assert s85)-Fast allSat, Looking for solution 728-[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 s89)-Fast allSat, Looking for solution 729-[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 s72)-Fast allSat, Looking for solution 730-[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 s61)-Fast allSat, Looking for solution 731-[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 s62)-Fast allSat, Looking for solution 732-[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 s63)-Fast allSat, Looking for solution 733-[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 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 1))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 735-[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 s66)-Fast allSat, Looking for solution 736-[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 s67)-Fast allSat, Looking for solution 737-[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 s68)-Fast allSat, Looking for solution 738-[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 s69)-Fast allSat, Looking for solution 739-[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 s70)-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 s43)-[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 2))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[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 3))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s46)-Fast allSat, Looking for solution 742-[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 s47)-Fast allSat, Looking for solution 743-[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 s48)-Fast allSat, Looking for solution 744-[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 s49)-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 10))-[GOOD] (push 1)-[GOOD] (assert s50)-Fast allSat, Looking for solution 746-[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 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 9))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s52)-Fast allSat, Looking for solution 748-[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 s53)-Fast allSat, Looking for solution 749-[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 13))-[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 13))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[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 14))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[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 14))-[GOOD] (push 1)-[GOOD] (assert s87)-Fast allSat, Looking for solution 753-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s72)-[GOOD] (assert s88)-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 s58)-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 12))-[GOOD] (push 1)-[GOOD] (assert s60)-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 s62)-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 s63)-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 s64)-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 s65)-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 s66)-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 s67)-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 s68)-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 s69)-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 s70)-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 s71)-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 s89)-[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 14))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 766-[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 s63)-Fast allSat, Looking for solution 767-[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 s64)-Fast allSat, Looking for solution 768-[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 s65)-Fast allSat, Looking for solution 769-[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 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 14))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 771-[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 s68)-Fast allSat, Looking for solution 772-[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 s69)-Fast allSat, Looking for solution 773-[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 s70)-Fast allSat, Looking for solution 774-[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 s71)-Fast allSat, Looking for solution 775-[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 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 14))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[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 s72)-[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 13))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 778-[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 s62)-Fast allSat, Looking for solution 779-[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 s63)-Fast allSat, Looking for solution 780-[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 s64)-Fast allSat, Looking for solution 781-[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 s65)-Fast allSat, Looking for solution 782-[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 s66)-Fast allSat, Looking for solution 783-[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 s67)-Fast allSat, Looking for solution 784-[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 s68)-Fast allSat, Looking for solution 785-[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 s69)-Fast allSat, Looking for solution 786-[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 s70)-Fast allSat, Looking for solution 787-[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 s71)-Fast allSat, Looking for solution 788-[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 s89)-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 s58)-[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 12))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s89)-Fast allSat, Looking for solution 790-[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 s72)-Fast allSat, Looking for solution 791-[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 s62)-Fast allSat, Looking for solution 792-[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 s63)-Fast allSat, Looking for solution 793-[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 s64)-Fast allSat, Looking for solution 794-[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 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 12))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 796-[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 s67)-Fast allSat, Looking for solution 797-[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 s68)-Fast allSat, Looking for solution 798-[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 s69)-Fast allSat, Looking for solution 799-[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 s70)-Fast allSat, Looking for solution 800-[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 s71)-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 s60)-[GOOD] (assert s76)-Fast allSat, Looking for solution 801-[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 s63)-Fast allSat, Looking for solution 802-[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 s64)-Fast allSat, Looking for solution 803-[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 s65)-Fast allSat, Looking for solution 804-[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 s66)-Fast allSat, Looking for solution 805-[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 s67)-Fast allSat, Looking for solution 806-[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 s68)-Fast allSat, Looking for solution 807-[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 s69)-Fast allSat, Looking for solution 808-[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 s70)-Fast allSat, Looking for solution 809-[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 s71)-Fast allSat, Looking for solution 810-[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 s58)-Fast allSat, Looking for solution 811-[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 s72)-Fast allSat, Looking for solution 812-[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 s89)-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 s62)-[GOOD] (assert s77)-Fast allSat, Looking for solution 813-[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 s89)-Fast allSat, Looking for solution 814-[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 s72)-Fast allSat, Looking for solution 815-[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 s58)-Fast allSat, Looking for solution 816-[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 s60)-Fast allSat, Looking for solution 817-[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 s64)-Fast allSat, Looking for solution 818-[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 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 9))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 820-[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 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 9))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 822-[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 s69)-Fast allSat, Looking for solution 823-[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 s70)-Fast allSat, Looking for solution 824-[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 s71)-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 s62)-[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 8))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 826-[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 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 8))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 828-[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 s68)-Fast allSat, Looking for solution 829-[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 s69)-Fast allSat, Looking for solution 830-[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 s70)-Fast allSat, Looking for solution 831-[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 s71)-Fast allSat, Looking for solution 832-[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 s63)-Fast allSat, Looking for solution 833-[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 s60)-Fast allSat, Looking for solution 834-[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 s58)-Fast allSat, Looking for solution 835-[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 s72)-Fast allSat, Looking for solution 836-[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 s89)-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 s62)-[GOOD] (assert s79)-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 9))-[GOOD] (push 1)-[GOOD] (assert s63)-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 12))-[GOOD] (push 1)-[GOOD] (assert s60)-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 13))-[GOOD] (push 1)-[GOOD] (assert s58)-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 14))-[GOOD] (push 1)-[GOOD] (assert s72)-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 15))-[GOOD] (push 1)-[GOOD] (assert s89)-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 s64)-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 s66)-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 s67)-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 s68)-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 s69)-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 s70)-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 s71)-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 s62)-[GOOD] (assert s80)-Fast allSat, Looking for solution 849-[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 s67)-Fast allSat, Looking for solution 850-[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 s68)-Fast allSat, Looking for solution 851-[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 s69)-Fast allSat, Looking for solution 852-[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 s70)-Fast allSat, Looking for solution 853-[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 s71)-Fast allSat, Looking for solution 854-[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 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 6))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 856-[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 s63)-Fast allSat, Looking for solution 857-[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 s60)-Fast allSat, Looking for solution 858-[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 s58)-Fast allSat, Looking for solution 859-[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 s72)-Fast allSat, Looking for solution 860-[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 s89)-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 s81)-Fast allSat, Looking for solution 861-[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 s89)-Fast allSat, Looking for solution 862-[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 s72)-Fast allSat, Looking for solution 863-[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 s58)-Fast allSat, Looking for solution 864-[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 s60)-Fast allSat, Looking for solution 865-[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 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 5))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[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 5))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 868-[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 s66)-Fast allSat, Looking for solution 869-[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 s68)-Fast allSat, Looking for solution 870-[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 s69)-Fast allSat, Looking for solution 871-[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 s70)-Fast allSat, Looking for solution 872-[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 s71)-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 s62)-[GOOD] (assert s82)-Fast allSat, Looking for solution 873-[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 s69)-Fast allSat, Looking for solution 874-[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 s70)-Fast allSat, Looking for solution 875-[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 s71)-Fast allSat, Looking for solution 876-[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 s67)-Fast allSat, Looking for solution 877-[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 s66)-Fast allSat, Looking for solution 878-[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 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 4))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 880-[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 s63)-Fast allSat, Looking for solution 881-[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 s60)-Fast allSat, Looking for solution 882-[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 s58)-Fast allSat, Looking for solution 883-[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 s72)-Fast allSat, Looking for solution 884-[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 s89)-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 s62)-[GOOD] (assert s83)-Fast allSat, Looking for solution 885-[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 s63)-Fast allSat, Looking for solution 886-[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 s60)-Fast allSat, Looking for solution 887-[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 s58)-Fast allSat, Looking for solution 888-[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 s72)-Fast allSat, Looking for solution 889-[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 s89)-Fast allSat, Looking for solution 890-[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 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 3))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 892-[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 s66)-Fast allSat, Looking for solution 893-[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 s67)-Fast allSat, Looking for solution 894-[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 s68)-Fast allSat, Looking for solution 895-[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 s70)-Fast allSat, Looking for solution 896-[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 s71)-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 s62)-[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 2))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 898-[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 s69)-Fast allSat, Looking for solution 899-[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 s68)-Fast allSat, Looking for solution 900-[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 s67)-Fast allSat, Looking for solution 901-[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 s66)-Fast allSat, Looking for solution 902-[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 s65)-Fast allSat, Looking for solution 903-[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 s64)-Fast allSat, Looking for solution 904-[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 s63)-Fast allSat, Looking for solution 905-[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 s60)-Fast allSat, Looking for solution 906-[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 s58)-Fast allSat, Looking for solution 907-[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 s72)-Fast allSat, Looking for solution 908-[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 s89)-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 s60)-[GOOD] (assert s92)-[GOOD] (assert s85)-Fast allSat, Looking for solution 909-[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 s89)-Fast allSat, Looking for solution 910-[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 s72)-Fast allSat, Looking for solution 911-[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 s58)-Fast allSat, Looking for solution 912-[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 s62)-Fast allSat, Looking for solution 913-[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 s63)-Fast allSat, Looking for solution 914-[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 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 1))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 916-[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 s66)-Fast allSat, Looking for solution 917-[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 s67)-Fast allSat, Looking for solution 918-[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 s68)-Fast allSat, Looking for solution 919-[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 s69)-Fast allSat, Looking for solution 920-[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 s70)-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 s43)-[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 2))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s45)-Fast allSat, Looking for solution 922-[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 s46)-Fast allSat, Looking for solution 923-[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 s47)-Fast allSat, Looking for solution 924-[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 s48)-Fast allSat, Looking for solution 925-[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 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 7))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[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 8))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[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 9))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[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 11))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[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 12))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[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 13))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[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 14))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[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 14))-[GOOD] (push 1)-[GOOD] (assert s87)-Fast allSat, Looking for solution 934-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s72)-[GOOD] (assert s88)-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 13))-[GOOD] (push 1)-[GOOD] (assert s58)-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 12))-[GOOD] (push 1)-[GOOD] (assert s60)-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 11))-[GOOD] (push 1)-[GOOD] (assert s61)-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 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 15))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[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 15))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[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 15))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[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 15))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s67)-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 s68)-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 s69)-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 s70)-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 s71)-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 s89)-[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 14))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 947-[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 s64)-Fast allSat, Looking for solution 948-[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 s65)-Fast allSat, Looking for solution 949-[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 s66)-Fast allSat, Looking for solution 950-[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 s67)-Fast allSat, Looking for solution 951-[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 s68)-Fast allSat, Looking for solution 952-[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 s69)-Fast allSat, Looking for solution 953-[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 s70)-Fast allSat, Looking for solution 954-[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 s71)-Fast allSat, Looking for solution 955-[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 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 14))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[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 14))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[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 s72)-[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 13))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 959-[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 s61)-Fast allSat, Looking for solution 960-[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 s63)-Fast allSat, Looking for solution 961-[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 s64)-Fast allSat, Looking for solution 962-[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 s65)-Fast allSat, Looking for solution 963-[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 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 13))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 965-[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 s68)-Fast allSat, Looking for solution 966-[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 s69)-Fast allSat, Looking for solution 967-[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 s70)-Fast allSat, Looking for solution 968-[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 s71)-Fast allSat, Looking for solution 969-[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 s89)-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 s58)-[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 12))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s89)-Fast allSat, Looking for solution 971-[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 s72)-Fast allSat, Looking for solution 972-[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 s61)-Fast allSat, Looking for solution 973-[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 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 12))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[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 12))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[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 12))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[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 12))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 978-[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 s68)-Fast allSat, Looking for solution 979-[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 s69)-Fast allSat, Looking for solution 980-[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 s70)-Fast allSat, Looking for solution 981-[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 s71)-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 s60)-[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 11))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 983-[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 s64)-Fast allSat, Looking for solution 984-[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 s65)-Fast allSat, Looking for solution 985-[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 s66)-Fast allSat, Looking for solution 986-[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 s67)-Fast allSat, Looking for solution 987-[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 s68)-Fast allSat, Looking for solution 988-[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 s69)-Fast allSat, Looking for solution 989-[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 s70)-Fast allSat, Looking for solution 990-[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 s71)-Fast allSat, Looking for solution 991-[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 s58)-Fast allSat, Looking for solution 992-[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 s72)-Fast allSat, Looking for solution 993-[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 s89)-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 s61)-[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 9))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s89)-Fast allSat, Looking for solution 995-[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 s72)-Fast allSat, Looking for solution 996-[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 s58)-Fast allSat, Looking for solution 997-[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 s60)-Fast allSat, Looking for solution 998-[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 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 9))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[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 9))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[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 9))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 1002-[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 s68)-Fast allSat, Looking for solution 1003-[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 s69)-Fast allSat, Looking for solution 1004-[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 s70)-Fast allSat, Looking for solution 1005-[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 s71)-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 s63)-[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 8))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 1007-[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 s66)-Fast allSat, Looking for solution 1008-[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 s67)-Fast allSat, Looking for solution 1009-[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 s68)-Fast allSat, Looking for solution 1010-[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 s69)-Fast allSat, Looking for solution 1011-[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 s70)-Fast allSat, Looking for solution 1012-[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 s71)-Fast allSat, Looking for solution 1013-[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 s61)-Fast allSat, Looking for solution 1014-[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 s60)-Fast allSat, Looking for solution 1015-[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 s58)-Fast allSat, Looking for solution 1016-[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 s72)-Fast allSat, Looking for solution 1017-[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 s89)-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 s63)-[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 7))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s89)-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 14))-[GOOD] (push 1)-[GOOD] (assert s72)-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 13))-[GOOD] (push 1)-[GOOD] (assert s58)-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 12))-[GOOD] (push 1)-[GOOD] (assert s60)-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 11))-[GOOD] (push 1)-[GOOD] (assert s61)-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 s64)-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 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 7))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s67)-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 s68)-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 s69)-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 s70)-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 s71)-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 s63)-[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 6))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 1031-[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 s68)-Fast allSat, Looking for solution 1032-[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 s69)-Fast allSat, Looking for solution 1033-[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 s70)-Fast allSat, Looking for solution 1034-[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 s71)-Fast allSat, Looking for solution 1035-[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 s65)-Fast allSat, Looking for solution 1036-[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 s64)-Fast allSat, Looking for solution 1037-[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 s61)-Fast allSat, Looking for solution 1038-[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 s60)-Fast allSat, Looking for solution 1039-[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 s58)-Fast allSat, Looking for solution 1040-[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 s72)-Fast allSat, Looking for solution 1041-[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 s89)-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 s63)-[GOOD] (assert s81)-Fast allSat, Looking for solution 1042-[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 s89)-Fast allSat, Looking for solution 1043-[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 s72)-Fast allSat, Looking for solution 1044-[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 s58)-Fast allSat, Looking for solution 1045-[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 s60)-Fast allSat, Looking for solution 1046-[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 s61)-Fast allSat, Looking for solution 1047-[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 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 5))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 1049-[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 s66)-Fast allSat, Looking for solution 1050-[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 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 5))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[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 5))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[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 5))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[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 s63)-[GOOD] (assert s82)-Fast allSat, Looking for solution 1054-[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 s69)-Fast allSat, Looking for solution 1055-[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 s70)-Fast allSat, Looking for solution 1056-[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 s71)-Fast allSat, Looking for solution 1057-[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 s67)-Fast allSat, Looking for solution 1058-[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 s66)-Fast allSat, Looking for solution 1059-[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 s65)-Fast allSat, Looking for solution 1060-[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 s64)-Fast allSat, Looking for solution 1061-[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 s61)-Fast allSat, Looking for solution 1062-[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 s60)-Fast allSat, Looking for solution 1063-[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 s58)-Fast allSat, Looking for solution 1064-[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 s72)-Fast allSat, Looking for solution 1065-[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 s89)-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 s63)-[GOOD] (assert s83)-Fast allSat, Looking for solution 1066-[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 s89)-Fast allSat, Looking for solution 1067-[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 s72)-Fast allSat, Looking for solution 1068-[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 s58)-Fast allSat, Looking for solution 1069-[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 s60)-Fast allSat, Looking for solution 1070-[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 s61)-Fast allSat, Looking for solution 1071-[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 s64)-Fast allSat, Looking for solution 1072-[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 s65)-Fast allSat, Looking for solution 1073-[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 s66)-Fast allSat, Looking for solution 1074-[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 s67)-Fast allSat, Looking for solution 1075-[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 s68)-Fast allSat, Looking for solution 1076-[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 s70)-Fast allSat, Looking for solution 1077-[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 s71)-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 s63)-[GOOD] (assert s84)-Fast allSat, Looking for solution 1078-[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 s71)-Fast allSat, Looking for solution 1079-[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 s69)-Fast allSat, Looking for solution 1080-[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 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 2))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 1082-[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 s66)-Fast allSat, Looking for solution 1083-[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 s65)-Fast allSat, Looking for solution 1084-[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 s64)-Fast allSat, Looking for solution 1085-[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 s61)-Fast allSat, Looking for solution 1086-[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 s60)-Fast allSat, Looking for solution 1087-[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 s58)-Fast allSat, Looking for solution 1088-[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 s72)-Fast allSat, Looking for solution 1089-[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 s89)-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 s61)-[GOOD] (assert s93)-[GOOD] (assert s85)-Fast allSat, Looking for solution 1090-[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 s89)-Fast allSat, Looking for solution 1091-[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 s72)-Fast allSat, Looking for solution 1092-[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 s58)-Fast allSat, Looking for solution 1093-[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 s60)-Fast allSat, Looking for solution 1094-[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 s63)-Fast allSat, Looking for solution 1095-[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 s64)-Fast allSat, Looking for solution 1096-[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 s65)-Fast allSat, Looking for solution 1097-[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 s66)-Fast allSat, Looking for solution 1098-[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 s67)-Fast allSat, Looking for solution 1099-[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 s68)-Fast allSat, Looking for solution 1100-[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 s69)-Fast allSat, Looking for solution 1101-[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 s70)-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 s43)-[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 2))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s45)-Fast allSat, Looking for solution 1103-[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 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 4))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s47)-Fast allSat, Looking for solution 1105-[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 s48)-Fast allSat, Looking for solution 1106-[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 s49)-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 8))-[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 8))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[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 10))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[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 11))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[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 12))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[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 13))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[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 14))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[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 8))-[GOOD] (push 1)-[GOOD] (assert s87)-Fast allSat, Looking for solution 1115-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s64)-[GOOD] (assert s88)-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 7))-[GOOD] (push 1)-[GOOD] (assert s65)-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 6))-[GOOD] (push 1)-[GOOD] (assert s66)-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 5))-[GOOD] (push 1)-[GOOD] (assert s67)-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 4))-[GOOD] (push 1)-[GOOD] (assert s68)-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 3))-[GOOD] (push 1)-[GOOD] (assert s69)-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 2))-[GOOD] (push 1)-[GOOD] (assert s70)-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 1))-[GOOD] (push 1)-[GOOD] (assert s71)-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 10))-[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 11))-[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 12))-[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 13))-[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 14))-[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 s64)-[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 14))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s89)-Fast allSat, Looking for solution 1128-[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 s58)-Fast allSat, Looking for solution 1129-[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 s60)-Fast allSat, Looking for solution 1130-[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 s61)-Fast allSat, Looking for solution 1131-[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 s62)-Fast allSat, Looking for solution 1132-[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 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 14))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 1134-[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 s67)-Fast allSat, Looking for solution 1135-[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 s68)-Fast allSat, Looking for solution 1136-[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 s69)-Fast allSat, Looking for solution 1137-[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 s70)-Fast allSat, Looking for solution 1138-[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 s71)-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 s64)-[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 13))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[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 13))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1141-[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 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 13))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1143-[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 s67)-Fast allSat, Looking for solution 1144-[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 s66)-Fast allSat, Looking for solution 1145-[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 s65)-Fast allSat, Looking for solution 1146-[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 s72)-Fast allSat, Looking for solution 1147-[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 s89)-Fast allSat, Looking for solution 1148-[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 s60)-Fast allSat, Looking for solution 1149-[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 s61)-Fast allSat, Looking for solution 1150-[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 s62)-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 s64)-[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 12))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1152-[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 s62)-Fast allSat, Looking for solution 1153-[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 s58)-Fast allSat, Looking for solution 1154-[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 s72)-Fast allSat, Looking for solution 1155-[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 s89)-Fast allSat, Looking for solution 1156-[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 s65)-Fast allSat, Looking for solution 1157-[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 s66)-Fast allSat, Looking for solution 1158-[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 s67)-Fast allSat, Looking for solution 1159-[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 s68)-Fast allSat, Looking for solution 1160-[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 s69)-Fast allSat, Looking for solution 1161-[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 s70)-Fast allSat, Looking for solution 1162-[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 s71)-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 s64)-[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 11))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[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 11))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1165-[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 s69)-Fast allSat, Looking for solution 1166-[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 s68)-Fast allSat, Looking for solution 1167-[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 s67)-Fast allSat, Looking for solution 1168-[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 s66)-Fast allSat, Looking for solution 1169-[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 s65)-Fast allSat, Looking for solution 1170-[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 s60)-Fast allSat, Looking for solution 1171-[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 s58)-Fast allSat, Looking for solution 1172-[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 s72)-Fast allSat, Looking for solution 1173-[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 s89)-Fast allSat, Looking for solution 1174-[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 s62)-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 s64)-[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 10))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[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 10))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[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 10))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[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 10))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[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 10))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s89)-Fast allSat, Looking for solution 1180-[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 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 10))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 1182-[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 s67)-Fast allSat, Looking for solution 1183-[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 s68)-Fast allSat, Looking for solution 1184-[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 s69)-Fast allSat, Looking for solution 1185-[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 s70)-Fast allSat, Looking for solution 1186-[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 s71)-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 s65)-[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 8))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[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 8))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[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 8))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[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 8))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[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 8))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[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 8))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 1193-[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 s62)-Fast allSat, Looking for solution 1194-[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 s61)-Fast allSat, Looking for solution 1195-[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 s60)-Fast allSat, Looking for solution 1196-[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 s58)-Fast allSat, Looking for solution 1197-[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 s72)-Fast allSat, Looking for solution 1198-[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 s89)-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 7))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s89)-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 14))-[GOOD] (push 1)-[GOOD] (assert s72)-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 13))-[GOOD] (push 1)-[GOOD] (assert s58)-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 12))-[GOOD] (push 1)-[GOOD] (assert s60)-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 11))-[GOOD] (push 1)-[GOOD] (assert s61)-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 10))-[GOOD] (push 1)-[GOOD] (assert s62)-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 6))-[GOOD] (push 1)-[GOOD] (assert s66)-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 5))-[GOOD] (push 1)-[GOOD] (assert s67)-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 4))-[GOOD] (push 1)-[GOOD] (assert s68)-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 3))-[GOOD] (push 1)-[GOOD] (assert s69)-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 2))-[GOOD] (push 1)-[GOOD] (assert s70)-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 1))-[GOOD] (push 1)-[GOOD] (assert s71)-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 s64)-[GOOD] (assert s80)-Fast allSat, Looking for solution 1211-[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 s67)-Fast allSat, Looking for solution 1212-[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 s68)-Fast allSat, Looking for solution 1213-[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 s69)-Fast allSat, Looking for solution 1214-[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 s70)-Fast allSat, Looking for solution 1215-[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 s71)-Fast allSat, Looking for solution 1216-[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 s65)-Fast allSat, Looking for solution 1217-[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 s62)-Fast allSat, Looking for solution 1218-[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 s61)-Fast allSat, Looking for solution 1219-[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 s60)-Fast allSat, Looking for solution 1220-[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 s58)-Fast allSat, Looking for solution 1221-[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 s72)-Fast allSat, Looking for solution 1222-[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 s89)-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 s64)-[GOOD] (assert s81)-Fast allSat, Looking for solution 1223-[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 s89)-Fast allSat, Looking for solution 1224-[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 s72)-Fast allSat, Looking for solution 1225-[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 s58)-Fast allSat, Looking for solution 1226-[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 s60)-Fast allSat, Looking for solution 1227-[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 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 5))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1229-[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 s65)-Fast allSat, Looking for solution 1230-[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 s66)-Fast allSat, Looking for solution 1231-[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 s68)-Fast allSat, Looking for solution 1232-[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 s69)-Fast allSat, Looking for solution 1233-[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 s70)-Fast allSat, Looking for solution 1234-[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 s71)-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 s64)-[GOOD] (assert s82)-Fast allSat, Looking for solution 1235-[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 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 4))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1237-[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 s71)-Fast allSat, Looking for solution 1238-[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 s67)-Fast allSat, Looking for solution 1239-[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 s66)-Fast allSat, Looking for solution 1240-[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 s65)-Fast allSat, Looking for solution 1241-[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 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 4))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[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 4))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[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 4))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[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 4))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[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 4))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s89)-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 s64)-[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 3))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s89)-Fast allSat, Looking for solution 1248-[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 s72)-Fast allSat, Looking for solution 1249-[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 s58)-Fast allSat, Looking for solution 1250-[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 s60)-Fast allSat, Looking for solution 1251-[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 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 3))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1253-[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 s65)-Fast allSat, Looking for solution 1254-[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 s66)-Fast allSat, Looking for solution 1255-[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 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 3))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[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 3))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[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 3))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s71)-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 s64)-[GOOD] (assert s84)-Fast allSat, Looking for solution 1259-[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 s71)-Fast allSat, Looking for solution 1260-[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 s69)-Fast allSat, Looking for solution 1261-[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 s68)-Fast allSat, Looking for solution 1262-[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 s67)-Fast allSat, Looking for solution 1263-[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 s66)-Fast allSat, Looking for solution 1264-[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 s65)-Fast allSat, Looking for solution 1265-[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 s62)-Fast allSat, Looking for solution 1266-[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 s61)-Fast allSat, Looking for solution 1267-[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 s60)-Fast allSat, Looking for solution 1268-[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 s58)-Fast allSat, Looking for solution 1269-[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 s72)-Fast allSat, Looking for solution 1270-[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 s89)-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 s62)-[GOOD] (assert s94)-[GOOD] (assert s85)-Fast allSat, Looking for solution 1271-[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 s89)-Fast allSat, Looking for solution 1272-[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 s72)-Fast allSat, Looking for solution 1273-[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 s58)-Fast allSat, Looking for solution 1274-[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 s60)-Fast allSat, Looking for solution 1275-[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 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 1))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[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 1))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 1278-[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 s66)-Fast allSat, Looking for solution 1279-[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 s67)-Fast allSat, Looking for solution 1280-[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 s68)-Fast allSat, Looking for solution 1281-[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 s69)-Fast allSat, Looking for solution 1282-[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 s70)-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 s43)-[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 2))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s45)-Fast allSat, Looking for solution 1284-[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 s46)-Fast allSat, Looking for solution 1285-[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 s47)-Fast allSat, Looking for solution 1286-[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 s48)-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 7))-[GOOD] (push 1)-[GOOD] (assert s49)-Fast allSat, Looking for solution 1288-[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 s50)-Fast allSat, Looking for solution 1289-[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 s52)-Fast allSat, Looking for solution 1290-[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 s53)-Fast allSat, Looking for solution 1291-[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 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 12))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s55)-Fast allSat, Looking for solution 1293-[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 s56)-Fast allSat, Looking for solution 1294-[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 s57)-Fast allSat, Looking for solution 1295-[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 s87)-Fast allSat, Looking for solution 1296-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s65)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1296-[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 s66)-Fast allSat, Looking for solution 1297-[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 s67)-Fast allSat, Looking for solution 1298-[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 s68)-Fast allSat, Looking for solution 1299-[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 s69)-Fast allSat, Looking for solution 1300-[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 s70)-Fast allSat, Looking for solution 1301-[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 s71)-Fast allSat, Looking for solution 1302-[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 s63)-Fast allSat, Looking for solution 1303-[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 s62)-Fast allSat, Looking for solution 1304-[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 s61)-Fast allSat, Looking for solution 1305-[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 s60)-Fast allSat, Looking for solution 1306-[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 s58)-Fast allSat, Looking for solution 1307-[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 s72)-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 s65)-[GOOD] (assert s59)-Fast allSat, Looking for solution 1308-[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 s58)-Fast allSat, Looking for solution 1309-[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 s60)-Fast allSat, Looking for solution 1310-[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 s61)-Fast allSat, Looking for solution 1311-[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 s62)-Fast allSat, Looking for solution 1312-[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 s63)-Fast allSat, Looking for solution 1313-[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 s89)-Fast allSat, Looking for solution 1314-[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 s66)-Fast allSat, Looking for solution 1315-[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 s67)-Fast allSat, Looking for solution 1316-[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 s68)-Fast allSat, Looking for solution 1317-[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 s69)-Fast allSat, Looking for solution 1318-[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 s70)-Fast allSat, Looking for solution 1319-[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 s71)-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 s65)-[GOOD] (assert s73)-Fast allSat, Looking for solution 1320-[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 s71)-Fast allSat, Looking for solution 1321-[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 s70)-Fast allSat, Looking for solution 1322-[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 s69)-Fast allSat, Looking for solution 1323-[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 s68)-Fast allSat, Looking for solution 1324-[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 s67)-Fast allSat, Looking for solution 1325-[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 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 13))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 1327-[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 s62)-Fast allSat, Looking for solution 1328-[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 s61)-Fast allSat, Looking for solution 1329-[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 s60)-Fast allSat, Looking for solution 1330-[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 s72)-Fast allSat, Looking for solution 1331-[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 s89)-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 s65)-[GOOD] (assert s74)-Fast allSat, Looking for solution 1332-[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 s89)-Fast allSat, Looking for solution 1333-[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 s72)-Fast allSat, Looking for solution 1334-[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 s58)-Fast allSat, Looking for solution 1335-[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 s61)-Fast allSat, Looking for solution 1336-[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 s62)-Fast allSat, Looking for solution 1337-[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 s63)-Fast allSat, Looking for solution 1338-[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 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 12))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[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 12))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[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 12))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[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 12))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[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 12))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[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 s65)-[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 11))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1345-[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 s70)-Fast allSat, Looking for solution 1346-[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 s69)-Fast allSat, Looking for solution 1347-[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 s68)-Fast allSat, Looking for solution 1348-[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 s67)-Fast allSat, Looking for solution 1349-[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 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 11))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 1351-[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 s62)-Fast allSat, Looking for solution 1352-[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 s60)-Fast allSat, Looking for solution 1353-[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 s58)-Fast allSat, Looking for solution 1354-[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 s72)-Fast allSat, Looking for solution 1355-[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 s89)-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 s65)-[GOOD] (assert s76)-Fast allSat, Looking for solution 1356-[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 s89)-Fast allSat, Looking for solution 1357-[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 s72)-Fast allSat, Looking for solution 1358-[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 s58)-Fast allSat, Looking for solution 1359-[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 s60)-Fast allSat, Looking for solution 1360-[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 s61)-Fast allSat, Looking for solution 1361-[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 s63)-Fast allSat, Looking for solution 1362-[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 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 10))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 1364-[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 s68)-Fast allSat, Looking for solution 1365-[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 s69)-Fast allSat, Looking for solution 1366-[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 s70)-Fast allSat, Looking for solution 1367-[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 s71)-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 s65)-[GOOD] (assert s77)-Fast allSat, Looking for solution 1368-[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 s71)-Fast allSat, Looking for solution 1369-[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 s70)-Fast allSat, Looking for solution 1370-[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 s69)-Fast allSat, Looking for solution 1371-[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 s68)-Fast allSat, Looking for solution 1372-[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 s67)-Fast allSat, Looking for solution 1373-[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 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 9))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1375-[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 s61)-Fast allSat, Looking for solution 1376-[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 s60)-Fast allSat, Looking for solution 1377-[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 s58)-Fast allSat, Looking for solution 1378-[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 s72)-Fast allSat, Looking for solution 1379-[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 s89)-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 s79)-Fast allSat, Looking for solution 1380-[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 s89)-Fast allSat, Looking for solution 1381-[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 s72)-Fast allSat, Looking for solution 1382-[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 s58)-Fast allSat, Looking for solution 1383-[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 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 7))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1385-[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 s62)-Fast allSat, Looking for solution 1386-[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 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 7))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[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 7))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[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 7))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[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 7))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1391-[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 s71)-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 s65)-[GOOD] (assert s80)-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 9))-[GOOD] (push 1)-[GOOD] (assert s63)-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 10))-[GOOD] (push 1)-[GOOD] (assert s62)-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 11))-[GOOD] (push 1)-[GOOD] (assert s61)-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 12))-[GOOD] (push 1)-[GOOD] (assert s60)-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 5))-[GOOD] (push 1)-[GOOD] (assert s67)-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 13))-[GOOD] (push 1)-[GOOD] (assert s58)-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 4))-[GOOD] (push 1)-[GOOD] (assert s68)-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 14))-[GOOD] (push 1)-[GOOD] (assert s72)-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 3))-[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 15))-[GOOD] (push 1)-[GOOD] (assert s89)-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 2))-[GOOD] (push 1)-[GOOD] (assert s70)-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 1))-[GOOD] (push 1)-[GOOD] (assert s71)-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 s65)-[GOOD] (assert s81)-Fast allSat, Looking for solution 1404-[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 s63)-Fast allSat, Looking for solution 1405-[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 s62)-Fast allSat, Looking for solution 1406-[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 s61)-Fast allSat, Looking for solution 1407-[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 s60)-Fast allSat, Looking for solution 1408-[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 s68)-Fast allSat, Looking for solution 1409-[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 s58)-Fast allSat, Looking for solution 1410-[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 s69)-Fast allSat, Looking for solution 1411-[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 s72)-Fast allSat, Looking for solution 1412-[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 s70)-Fast allSat, Looking for solution 1413-[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 s89)-Fast allSat, Looking for solution 1414-[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 s71)-Fast allSat, Looking for solution 1415-[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 s66)-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 s65)-[GOOD] (assert s82)-Fast allSat, Looking for solution 1416-[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 s63)-Fast allSat, Looking for solution 1417-[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 s62)-Fast allSat, Looking for solution 1418-[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 s61)-Fast allSat, Looking for solution 1419-[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 s60)-Fast allSat, Looking for solution 1420-[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 s69)-Fast allSat, Looking for solution 1421-[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 s58)-Fast allSat, Looking for solution 1422-[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 s70)-Fast allSat, Looking for solution 1423-[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 s72)-Fast allSat, Looking for solution 1424-[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 s71)-Fast allSat, Looking for solution 1425-[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 s89)-Fast allSat, Looking for solution 1426-[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 s66)-Fast allSat, Looking for solution 1427-[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 s67)-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 s65)-[GOOD] (assert s83)-Fast allSat, Looking for solution 1428-[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 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 3))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[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 3))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[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 3))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[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 3))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1433-[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 s58)-Fast allSat, Looking for solution 1434-[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 s71)-Fast allSat, Looking for solution 1435-[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 s72)-Fast allSat, Looking for solution 1436-[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 s66)-Fast allSat, Looking for solution 1437-[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 s89)-Fast allSat, Looking for solution 1438-[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 s67)-Fast allSat, Looking for solution 1439-[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 s68)-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 s65)-[GOOD] (assert s84)-Fast allSat, Looking for solution 1440-[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 s63)-Fast allSat, Looking for solution 1441-[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 s62)-Fast allSat, Looking for solution 1442-[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 s61)-Fast allSat, Looking for solution 1443-[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 s60)-Fast allSat, Looking for solution 1444-[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 s71)-Fast allSat, Looking for solution 1445-[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 s58)-Fast allSat, Looking for solution 1446-[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 s66)-Fast allSat, Looking for solution 1447-[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 s72)-Fast allSat, Looking for solution 1448-[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 s67)-Fast allSat, Looking for solution 1449-[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 s89)-Fast allSat, Looking for solution 1450-[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 s68)-Fast allSat, Looking for solution 1451-[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 s69)-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 s63)-[GOOD] (assert s95)-[GOOD] (assert s85)-Fast allSat, Looking for solution 1452-[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 s62)-Fast allSat, Looking for solution 1453-[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 s61)-Fast allSat, Looking for solution 1454-[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 s65)-Fast allSat, Looking for solution 1455-[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 s60)-Fast allSat, Looking for solution 1456-[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 s66)-Fast allSat, Looking for solution 1457-[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 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 1))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 1459-[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 s72)-Fast allSat, Looking for solution 1460-[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 s68)-Fast allSat, Looking for solution 1461-[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 s89)-Fast allSat, Looking for solution 1462-[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 s69)-Fast allSat, Looking for solution 1463-[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 s70)-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 s43)-[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 8))-[GOOD] (push 1)-[GOOD] (assert s52)-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 8))-[GOOD] (push 1)-[GOOD] (assert s53)-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 8))-[GOOD] (push 1)-[GOOD] (assert s54)-Fast allSat, Looking for solution 1467-[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 s49)-Fast allSat, Looking for solution 1468-[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 s55)-Fast allSat, Looking for solution 1469-[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 s48)-Fast allSat, Looking for solution 1470-[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 s56)-Fast allSat, Looking for solution 1471-[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 s47)-Fast allSat, Looking for solution 1472-[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 s57)-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 s46)-Fast allSat, Looking for solution 1474-[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 s87)-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 8))-[GOOD] (push 1)-[GOOD] (assert s45)-Fast allSat, Looking for solution 1476-[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 9))-[GOOD] (push 1)-[GOOD] (assert s51)-Fast allSat, Looking for solution 1477-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s63)-[GOOD] (assert s78)-Fast allSat, Looking for solution 1477-[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 s62)-Fast allSat, Looking for solution 1478-[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 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 8))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 1480-[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 s60)-Fast allSat, Looking for solution 1481-[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 s67)-Fast allSat, Looking for solution 1482-[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 s58)-Fast allSat, Looking for solution 1483-[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 s68)-Fast allSat, Looking for solution 1484-[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 s72)-Fast allSat, Looking for solution 1485-[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 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 8))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s89)-Fast allSat, Looking for solution 1487-[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 s70)-Fast allSat, Looking for solution 1488-[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 s71)-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 s64)-[GOOD] (assert s84)-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 9))-[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 10))-[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 1))-[GOOD] (push 1)-[GOOD] (assert s71)-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 11))-[GOOD] (push 1)-[GOOD] (assert s61)-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 6))-[GOOD] (push 1)-[GOOD] (assert s66)-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 12))-[GOOD] (push 1)-[GOOD] (assert s60)-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 5))-[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 13))-[GOOD] (push 1)-[GOOD] (assert s58)-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 4))-[GOOD] (push 1)-[GOOD] (assert s68)-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 14))-[GOOD] (push 1)-[GOOD] (assert s72)-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 3))-[GOOD] (push 1)-[GOOD] (assert s69)-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 s89)-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 s64)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1501-[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 s72)-Fast allSat, Looking for solution 1502-[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 s58)-Fast allSat, Looking for solution 1503-[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 s60)-Fast allSat, Looking for solution 1504-[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 s61)-Fast allSat, Looking for solution 1505-[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 s62)-Fast allSat, Looking for solution 1506-[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 s63)-Fast allSat, Looking for solution 1507-[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 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 15))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 1509-[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 s68)-Fast allSat, Looking for solution 1510-[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 s69)-Fast allSat, Looking for solution 1511-[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 s70)-Fast allSat, Looking for solution 1512-[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 s71)-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 s64)-[GOOD] (assert s83)-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 9))-[GOOD] (push 1)-[GOOD] (assert s63)-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 10))-[GOOD] (push 1)-[GOOD] (assert s62)-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 2))-[GOOD] (push 1)-[GOOD] (assert s70)-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 11))-[GOOD] (push 1)-[GOOD] (assert s61)-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 1))-[GOOD] (push 1)-[GOOD] (assert s71)-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 12))-[GOOD] (push 1)-[GOOD] (assert s60)-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 6))-[GOOD] (push 1)-[GOOD] (assert s66)-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 13))-[GOOD] (push 1)-[GOOD] (assert s58)-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 5))-[GOOD] (push 1)-[GOOD] (assert s67)-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 14))-[GOOD] (push 1)-[GOOD] (assert s72)-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 4))-[GOOD] (push 1)-[GOOD] (assert s68)-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 s89)-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 s64)-[GOOD] (assert s59)-Fast allSat, Looking for solution 1525-[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 s58)-Fast allSat, Looking for solution 1526-[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 s60)-Fast allSat, Looking for solution 1527-[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 s61)-Fast allSat, Looking for solution 1528-[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 s62)-Fast allSat, Looking for solution 1529-[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 s63)-Fast allSat, Looking for solution 1530-[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 s89)-Fast allSat, Looking for solution 1531-[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 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 14))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 1533-[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 s68)-Fast allSat, Looking for solution 1534-[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 s69)-Fast allSat, Looking for solution 1535-[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 s70)-Fast allSat, Looking for solution 1536-[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 s71)-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 s64)-[GOOD] (assert s82)-Fast allSat, Looking for solution 1537-[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 s63)-Fast allSat, Looking for solution 1538-[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 s62)-Fast allSat, Looking for solution 1539-[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 s69)-Fast allSat, Looking for solution 1540-[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 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 4))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1542-[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 s60)-Fast allSat, Looking for solution 1543-[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 s71)-Fast allSat, Looking for solution 1544-[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 s58)-Fast allSat, Looking for solution 1545-[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 s66)-Fast allSat, Looking for solution 1546-[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 s72)-Fast allSat, Looking for solution 1547-[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 s67)-Fast allSat, Looking for solution 1548-[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 s89)-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 s64)-[GOOD] (assert s73)-Fast allSat, Looking for solution 1549-[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 s60)-Fast allSat, Looking for solution 1550-[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 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 13))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1552-[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 s63)-Fast allSat, Looking for solution 1553-[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 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 13))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[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 13))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s89)-Fast allSat, Looking for solution 1556-[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 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 13))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[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 13))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[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 13))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[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 13))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[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 s64)-[GOOD] (assert s81)-Fast allSat, Looking for solution 1561-[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 s63)-Fast allSat, Looking for solution 1562-[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 s62)-Fast allSat, Looking for solution 1563-[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 s68)-Fast allSat, Looking for solution 1564-[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 s61)-Fast allSat, Looking for solution 1565-[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 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 5))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1567-[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 s70)-Fast allSat, Looking for solution 1568-[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 s58)-Fast allSat, Looking for solution 1569-[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 s71)-Fast allSat, Looking for solution 1570-[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 s72)-Fast allSat, Looking for solution 1571-[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 s66)-Fast allSat, Looking for solution 1572-[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 s89)-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 s64)-[GOOD] (assert s74)-Fast allSat, Looking for solution 1573-[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 s61)-Fast allSat, Looking for solution 1574-[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 s62)-Fast allSat, Looking for solution 1575-[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 s63)-Fast allSat, Looking for solution 1576-[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 s58)-Fast allSat, Looking for solution 1577-[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 s66)-Fast allSat, Looking for solution 1578-[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 s72)-Fast allSat, Looking for solution 1579-[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 s67)-Fast allSat, Looking for solution 1580-[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 s89)-Fast allSat, Looking for solution 1581-[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 s68)-Fast allSat, Looking for solution 1582-[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 s69)-Fast allSat, Looking for solution 1583-[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 s70)-Fast allSat, Looking for solution 1584-[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 s71)-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 s64)-[GOOD] (assert s80)-Fast allSat, Looking for solution 1585-[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 s63)-Fast allSat, Looking for solution 1586-[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 s62)-Fast allSat, Looking for solution 1587-[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 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 6))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[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 6))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s68)-Fast allSat, Looking for solution 1590-[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 s60)-Fast allSat, Looking for solution 1591-[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 s69)-Fast allSat, Looking for solution 1592-[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 s58)-Fast allSat, Looking for solution 1593-[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 s70)-Fast allSat, Looking for solution 1594-[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 s72)-Fast allSat, Looking for solution 1595-[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 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 6))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s89)-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 s64)-[GOOD] (assert s75)-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 10))-[GOOD] (push 1)-[GOOD] (assert s62)-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 s63)-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 12))-[GOOD] (push 1)-[GOOD] (assert s60)-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 s66)-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 13))-[GOOD] (push 1)-[GOOD] (assert s58)-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 s67)-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 14))-[GOOD] (push 1)-[GOOD] (assert s72)-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 s68)-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 s89)-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 s69)-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 s70)-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 s71)-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 s64)-[GOOD] (assert s76)-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 9))-[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 11))-[GOOD] (push 1)-[GOOD] (assert s61)-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 s66)-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 12))-[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 5))-[GOOD] (push 1)-[GOOD] (assert s67)-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 13))-[GOOD] (push 1)-[GOOD] (assert s58)-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 s68)-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 14))-[GOOD] (push 1)-[GOOD] (assert s72)-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 s69)-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 15))-[GOOD] (push 1)-[GOOD] (assert s89)-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 s70)-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 s71)-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 s64)-[GOOD] (assert s77)-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 10))-[GOOD] (push 1)-[GOOD] (assert s62)-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 11))-[GOOD] (push 1)-[GOOD] (assert s61)-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 12))-[GOOD] (push 1)-[GOOD] (assert s60)-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 6))-[GOOD] (push 1)-[GOOD] (assert s66)-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 13))-[GOOD] (push 1)-[GOOD] (assert s58)-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 5))-[GOOD] (push 1)-[GOOD] (assert s67)-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 14))-[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 4))-[GOOD] (push 1)-[GOOD] (assert s68)-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 15))-[GOOD] (push 1)-[GOOD] (assert s89)-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 3))-[GOOD] (push 1)-[GOOD] (assert s69)-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 2))-[GOOD] (push 1)-[GOOD] (assert s70)-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 1))-[GOOD] (push 1)-[GOOD] (assert s71)-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 s64)-[GOOD] (assert s96)-[GOOD] (assert s85)-Fast allSat, Looking for solution 1633-[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 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 1))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[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 1))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[GOOD] (push 1)-[GOOD] (assert s66)-Fast allSat, Looking for solution 1636-[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 s61)-Fast allSat, Looking for solution 1637-[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 s67)-Fast allSat, Looking for solution 1638-[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 s60)-Fast allSat, Looking for solution 1639-[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 s68)-Fast allSat, Looking for solution 1640-[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 s58)-Fast allSat, Looking for solution 1641-[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 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 1))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[GOOD] (push 1)-[GOOD] (assert s72)-Fast allSat, Looking for solution 1643-[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 s70)-Fast allSat, Looking for solution 1644-[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 s89)-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 s43)-[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 s51)-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 7))-[GOOD] (push 1)-[GOOD] (assert s52)-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 7))-[GOOD] (push 1)-[GOOD] (assert s53)-Fast allSat, Looking for solution 1648-[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 s48)-Fast allSat, Looking for solution 1649-[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 s54)-Fast allSat, Looking for solution 1650-[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 s47)-Fast allSat, Looking for solution 1651-[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 s55)-Fast allSat, Looking for solution 1652-[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 s46)-Fast allSat, Looking for solution 1653-[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 s56)-Fast allSat, Looking for solution 1654-[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 s45)-Fast allSat, Looking for solution 1655-[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 s57)-Fast allSat, Looking for solution 1656-[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 s87)-Fast allSat, Looking for solution 1657-[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 8))-[GOOD] (push 1)-[GOOD] (assert s50)-Fast allSat, Looking for solution 1658-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s64)-[GOOD] (assert s79)-Fast allSat, Looking for solution 1658-[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 s63)-Fast allSat, Looking for solution 1659-[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 s62)-Fast allSat, Looking for solution 1660-[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 s61)-Fast allSat, Looking for solution 1661-[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 s60)-Fast allSat, Looking for solution 1662-[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 s58)-Fast allSat, Looking for solution 1663-[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 s72)-Fast allSat, Looking for solution 1664-[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 s89)-Fast allSat, Looking for solution 1665-[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 s67)-Fast allSat, Looking for solution 1666-[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 s68)-Fast allSat, Looking for solution 1667-[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 s69)-Fast allSat, Looking for solution 1668-[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 s70)-Fast allSat, Looking for solution 1669-[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 s71)-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 s65)-[GOOD] (assert s88)-Fast allSat, Looking for solution 1670-[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 s64)-Fast allSat, Looking for solution 1671-[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 s63)-Fast allSat, Looking for solution 1672-[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 s62)-Fast allSat, Looking for solution 1673-[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 s61)-Fast allSat, Looking for solution 1674-[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 s60)-Fast allSat, Looking for solution 1675-[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 s58)-Fast allSat, Looking for solution 1676-[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 s72)-Fast allSat, Looking for solution 1677-[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 s67)-Fast allSat, Looking for solution 1678-[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 s68)-Fast allSat, Looking for solution 1679-[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 s69)-Fast allSat, Looking for solution 1680-[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 s70)-Fast allSat, Looking for solution 1681-[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 s71)-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 s65)-[GOOD] (assert s59)-Fast allSat, Looking for solution 1682-[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 s67)-Fast allSat, Looking for solution 1683-[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 s68)-Fast allSat, Looking for solution 1684-[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 s69)-Fast allSat, Looking for solution 1685-[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 s70)-Fast allSat, Looking for solution 1686-[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 s71)-Fast allSat, Looking for solution 1687-[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 s64)-Fast allSat, Looking for solution 1688-[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 s63)-Fast allSat, Looking for solution 1689-[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 s62)-Fast allSat, Looking for solution 1690-[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 s61)-Fast allSat, Looking for solution 1691-[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 s60)-Fast allSat, Looking for solution 1692-[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 s58)-Fast allSat, Looking for solution 1693-[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 s89)-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 s65)-[GOOD] (assert s84)-Fast allSat, Looking for solution 1694-[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 s64)-Fast allSat, Looking for solution 1695-[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 s63)-Fast allSat, Looking for solution 1696-[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 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 2))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1698-[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 s60)-Fast allSat, Looking for solution 1699-[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 s58)-Fast allSat, Looking for solution 1700-[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 s72)-Fast allSat, Looking for solution 1701-[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 s89)-Fast allSat, Looking for solution 1702-[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 s71)-Fast allSat, Looking for solution 1703-[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 s69)-Fast allSat, Looking for solution 1704-[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 s68)-Fast allSat, Looking for solution 1705-[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 s67)-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 s65)-[GOOD] (assert s73)-Fast allSat, Looking for solution 1706-[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 s67)-Fast allSat, Looking for solution 1707-[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 s68)-Fast allSat, Looking for solution 1708-[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 s69)-Fast allSat, Looking for solution 1709-[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 s70)-Fast allSat, Looking for solution 1710-[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 s71)-Fast allSat, Looking for solution 1711-[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 s64)-Fast allSat, Looking for solution 1712-[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 s63)-Fast allSat, Looking for solution 1713-[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 s62)-Fast allSat, Looking for solution 1714-[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 s61)-Fast allSat, Looking for solution 1715-[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 s60)-Fast allSat, Looking for solution 1716-[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 s72)-Fast allSat, Looking for solution 1717-[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 s89)-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 s65)-[GOOD] (assert s83)-Fast allSat, Looking for solution 1718-[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 s89)-Fast allSat, Looking for solution 1719-[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 s72)-Fast allSat, Looking for solution 1720-[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 s58)-Fast allSat, Looking for solution 1721-[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 s60)-Fast allSat, Looking for solution 1722-[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 s61)-Fast allSat, Looking for solution 1723-[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 s62)-Fast allSat, Looking for solution 1724-[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 s63)-Fast allSat, Looking for solution 1725-[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 s64)-Fast allSat, Looking for solution 1726-[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 s70)-Fast allSat, Looking for solution 1727-[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 s71)-Fast allSat, Looking for solution 1728-[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 s68)-Fast allSat, Looking for solution 1729-[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 s67)-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 s65)-[GOOD] (assert s74)-Fast allSat, Looking for solution 1730-[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 s67)-Fast allSat, Looking for solution 1731-[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 s68)-Fast allSat, Looking for solution 1732-[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 s69)-Fast allSat, Looking for solution 1733-[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 s70)-Fast allSat, Looking for solution 1734-[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 s71)-Fast allSat, Looking for solution 1735-[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 s64)-Fast allSat, Looking for solution 1736-[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 s63)-Fast allSat, Looking for solution 1737-[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 s62)-Fast allSat, Looking for solution 1738-[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 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 12))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1740-[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 s72)-Fast allSat, Looking for solution 1741-[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 s89)-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 s65)-[GOOD] (assert s82)-Fast allSat, Looking for solution 1742-[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 s89)-Fast allSat, Looking for solution 1743-[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 s72)-Fast allSat, Looking for solution 1744-[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 s58)-Fast allSat, Looking for solution 1745-[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 s60)-Fast allSat, Looking for solution 1746-[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 s61)-Fast allSat, Looking for solution 1747-[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 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 4))-[SEND] (get-value (s2))-[RECV] ((s2 9))-[GOOD] (push 1)-[GOOD] (assert s63)-Fast allSat, Looking for solution 1749-[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 s64)-Fast allSat, Looking for solution 1750-[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 s69)-Fast allSat, Looking for solution 1751-[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 s70)-Fast allSat, Looking for solution 1752-[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 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 4))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s67)-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 s65)-[GOOD] (assert s75)-Fast allSat, Looking for solution 1754-[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 s67)-Fast allSat, Looking for solution 1755-[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 s68)-Fast allSat, Looking for solution 1756-[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 s69)-Fast allSat, Looking for solution 1757-[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 s70)-Fast allSat, Looking for solution 1758-[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 s71)-Fast allSat, Looking for solution 1759-[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 s64)-Fast allSat, Looking for solution 1760-[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 s63)-Fast allSat, Looking for solution 1761-[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 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 11))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1763-[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 s58)-Fast allSat, Looking for solution 1764-[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 s72)-Fast allSat, Looking for solution 1765-[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 s89)-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 s65)-[GOOD] (assert s81)-Fast allSat, Looking for solution 1766-[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 s89)-Fast allSat, Looking for solution 1767-[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 s72)-Fast allSat, Looking for solution 1768-[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 s58)-Fast allSat, Looking for solution 1769-[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 s60)-Fast allSat, Looking for solution 1770-[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 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 5))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1772-[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 s63)-Fast allSat, Looking for solution 1773-[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 s64)-Fast allSat, Looking for solution 1774-[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 s68)-Fast allSat, Looking for solution 1775-[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 s69)-Fast allSat, Looking for solution 1776-[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 s70)-Fast allSat, Looking for solution 1777-[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 s71)-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 s65)-[GOOD] (assert s76)-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 s67)-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 s68)-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 s69)-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 s70)-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 1))-[GOOD] (push 1)-[GOOD] (assert s71)-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 s64)-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 s63)-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 s61)-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 s60)-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 s58)-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 s72)-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 s89)-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 s77)-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 15))-[GOOD] (push 1)-[GOOD] (assert s89)-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 14))-[GOOD] (push 1)-[GOOD] (assert s72)-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 13))-[GOOD] (push 1)-[GOOD] (assert s58)-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 12))-[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 11))-[GOOD] (push 1)-[GOOD] (assert s61)-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 10))-[GOOD] (push 1)-[GOOD] (assert s62)-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 8))-[GOOD] (push 1)-[GOOD] (assert s64)-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 5))-[GOOD] (push 1)-[GOOD] (assert s67)-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 4))-[GOOD] (push 1)-[GOOD] (assert s68)-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 3))-[GOOD] (push 1)-[GOOD] (assert s69)-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 2))-[GOOD] (push 1)-[GOOD] (assert s70)-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 1))-[GOOD] (push 1)-[GOOD] (assert s71)-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 s65)-[GOOD] (assert s78)-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 s67)-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 s68)-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 s69)-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 s70)-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 1))-[GOOD] (push 1)-[GOOD] (assert s71)-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 s63)-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 s62)-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 s61)-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 s60)-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 s58)-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 s72)-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 s89)-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 s85)-Fast allSat, Looking for solution 1814-[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 s89)-Fast allSat, Looking for solution 1815-[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 s72)-Fast allSat, Looking for solution 1816-[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 s58)-Fast allSat, Looking for solution 1817-[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 s60)-Fast allSat, Looking for solution 1818-[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 s61)-Fast allSat, Looking for solution 1819-[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 s62)-Fast allSat, Looking for solution 1820-[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 s63)-Fast allSat, Looking for solution 1821-[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 s64)-Fast allSat, Looking for solution 1822-[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 s67)-Fast allSat, Looking for solution 1823-[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 s68)-Fast allSat, Looking for solution 1824-[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 s69)-Fast allSat, Looking for solution 1825-[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 s70)-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 s43)-[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 2))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[GOOD] (push 1)-[GOOD] (assert s45)-Fast allSat, Looking for solution 1827-[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 s46)-Fast allSat, Looking for solution 1828-[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 s47)-Fast allSat, Looking for solution 1829-[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 s49)-Fast allSat, Looking for solution 1830-[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 s50)-Fast allSat, Looking for solution 1831-[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 s51)-Fast allSat, Looking for solution 1832-[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 s52)-Fast allSat, Looking for solution 1833-[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 s53)-Fast allSat, Looking for solution 1834-[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 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 12))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[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 13))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[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 14))-[SEND] (get-value (s2))-[RECV] ((s2 4))-[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 4))-[GOOD] (push 1)-[GOOD] (assert s87)-Fast allSat, Looking for solution 1839-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s68)-[GOOD] (assert s88)-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 3))-[GOOD] (push 1)-[GOOD] (assert s69)-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 2))-[GOOD] (push 1)-[GOOD] (assert s70)-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 1))-[GOOD] (push 1)-[GOOD] (assert s71)-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 6))-[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 15))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s65)-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 8))-[GOOD] (push 1)-[GOOD] (assert s64)-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 9))-[GOOD] (push 1)-[GOOD] (assert s63)-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 10))-[GOOD] (push 1)-[GOOD] (assert s62)-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 11))-[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 12))-[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 13))-[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 14))-[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 s68)-[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 14))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1852-[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 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 14))-[SEND] (get-value (s2))-[RECV] ((s2 11))-[GOOD] (push 1)-[GOOD] (assert s61)-Fast allSat, Looking for solution 1854-[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 s62)-Fast allSat, Looking for solution 1855-[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 s63)-Fast allSat, Looking for solution 1856-[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 s64)-Fast allSat, Looking for solution 1857-[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 s65)-Fast allSat, Looking for solution 1858-[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 s66)-Fast allSat, Looking for solution 1859-[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 s89)-Fast allSat, Looking for solution 1860-[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 s69)-Fast allSat, Looking for solution 1861-[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 s70)-Fast allSat, Looking for solution 1862-[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 s71)-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 s68)-[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 13))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[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 13))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 1865-[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 s69)-Fast allSat, Looking for solution 1866-[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 s66)-Fast allSat, Looking for solution 1867-[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 s65)-Fast allSat, Looking for solution 1868-[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 s64)-Fast allSat, Looking for solution 1869-[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 s63)-Fast allSat, Looking for solution 1870-[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 s62)-Fast allSat, Looking for solution 1871-[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 s61)-Fast allSat, Looking for solution 1872-[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 s60)-Fast allSat, Looking for solution 1873-[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 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 13))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s89)-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 s68)-[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 12))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s89)-Fast allSat, Looking for solution 1876-[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 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 12))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[GOOD] (push 1)-[GOOD] (assert s58)-Fast allSat, Looking for solution 1878-[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 s61)-Fast allSat, Looking for solution 1879-[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 s62)-Fast allSat, Looking for solution 1880-[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 s63)-Fast allSat, Looking for solution 1881-[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 s64)-Fast allSat, Looking for solution 1882-[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 s65)-Fast allSat, Looking for solution 1883-[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 s66)-Fast allSat, Looking for solution 1884-[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 s69)-Fast allSat, Looking for solution 1885-[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 s70)-Fast allSat, Looking for solution 1886-[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 s71)-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 s68)-[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 11))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s71)-Fast allSat, Looking for solution 1888-[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 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 11))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 1890-[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 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 11))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 1892-[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 s64)-Fast allSat, Looking for solution 1893-[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 s63)-Fast allSat, Looking for solution 1894-[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 s62)-Fast allSat, Looking for solution 1895-[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 s60)-Fast allSat, Looking for solution 1896-[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 s58)-Fast allSat, Looking for solution 1897-[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 s72)-Fast allSat, Looking for solution 1898-[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 s89)-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 s68)-[GOOD] (assert s76)-Fast allSat, Looking for solution 1899-[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 s89)-Fast allSat, Looking for solution 1900-[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 s72)-Fast allSat, Looking for solution 1901-[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 s58)-Fast allSat, Looking for solution 1902-[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 s60)-Fast allSat, Looking for solution 1903-[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 s61)-Fast allSat, Looking for solution 1904-[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 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 10))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 1906-[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 s65)-Fast allSat, Looking for solution 1907-[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 s66)-Fast allSat, Looking for solution 1908-[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 s69)-Fast allSat, Looking for solution 1909-[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 s70)-Fast allSat, Looking for solution 1910-[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 s71)-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 s68)-[GOOD] (assert s77)-Fast allSat, Looking for solution 1911-[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 s71)-Fast allSat, Looking for solution 1912-[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 s70)-Fast allSat, Looking for solution 1913-[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 s69)-Fast allSat, Looking for solution 1914-[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 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 9))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[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 9))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[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 9))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1918-[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 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 9))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[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 9))-[SEND] (get-value (s2))-[RECV] ((s2 13))-[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 9))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[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 9))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s89)-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 s68)-[GOOD] (assert s78)-Fast allSat, Looking for solution 1923-[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 s89)-Fast allSat, Looking for solution 1924-[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 s72)-Fast allSat, Looking for solution 1925-[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 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 8))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1927-[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 s61)-Fast allSat, Looking for solution 1928-[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 s62)-Fast allSat, Looking for solution 1929-[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 s63)-Fast allSat, Looking for solution 1930-[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 s65)-Fast allSat, Looking for solution 1931-[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 s66)-Fast allSat, Looking for solution 1932-[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 s69)-Fast allSat, Looking for solution 1933-[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 s70)-Fast allSat, Looking for solution 1934-[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 s71)-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 s68)-[GOOD] (assert s79)-Fast allSat, Looking for solution 1935-[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 s71)-Fast allSat, Looking for solution 1936-[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 s70)-Fast allSat, Looking for solution 1937-[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 s69)-Fast allSat, Looking for solution 1938-[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 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 7))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s64)-Fast allSat, Looking for solution 1940-[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 s63)-Fast allSat, Looking for solution 1941-[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 s62)-Fast allSat, Looking for solution 1942-[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 s61)-Fast allSat, Looking for solution 1943-[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 s60)-Fast allSat, Looking for solution 1944-[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 s58)-Fast allSat, Looking for solution 1945-[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 s72)-Fast allSat, Looking for solution 1946-[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 s89)-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 s80)-Fast allSat, Looking for solution 1947-[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 s89)-Fast allSat, Looking for solution 1948-[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 s72)-Fast allSat, Looking for solution 1949-[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 s58)-Fast allSat, Looking for solution 1950-[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 s60)-Fast allSat, Looking for solution 1951-[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 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 6))-[SEND] (get-value (s2))-[RECV] ((s2 10))-[GOOD] (push 1)-[GOOD] (assert s62)-Fast allSat, Looking for solution 1953-[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 s63)-Fast allSat, Looking for solution 1954-[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 s64)-Fast allSat, Looking for solution 1955-[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 7))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 1956-[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 s69)-Fast allSat, Looking for solution 1957-[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 s70)-Fast allSat, Looking for solution 1958-[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 s71)-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 s69)-[GOOD] (assert s82)-Fast allSat, Looking for solution 1959-[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 s71)-Fast allSat, Looking for solution 1960-[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 s70)-Fast allSat, Looking for solution 1961-[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 s66)-Fast allSat, Looking for solution 1962-[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 s65)-Fast allSat, Looking for solution 1963-[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 s64)-Fast allSat, Looking for solution 1964-[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 s63)-Fast allSat, Looking for solution 1965-[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 s62)-Fast allSat, Looking for solution 1966-[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 s61)-Fast allSat, Looking for solution 1967-[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 s60)-Fast allSat, Looking for solution 1968-[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 s58)-Fast allSat, Looking for solution 1969-[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 s72)-Fast allSat, Looking for solution 1970-[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 s89)-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 s68)-[GOOD] (assert s83)-Fast allSat, Looking for solution 1971-[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 s89)-Fast allSat, Looking for solution 1972-[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 s72)-Fast allSat, Looking for solution 1973-[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 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 3))-[SEND] (get-value (s2))-[RECV] ((s2 12))-[GOOD] (push 1)-[GOOD] (assert s60)-Fast allSat, Looking for solution 1975-[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 s61)-Fast allSat, Looking for solution 1976-[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 s62)-Fast allSat, Looking for solution 1977-[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 s63)-Fast allSat, Looking for solution 1978-[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 s64)-Fast allSat, Looking for solution 1979-[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 s65)-Fast allSat, Looking for solution 1980-[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 s66)-Fast allSat, Looking for solution 1981-[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 s70)-Fast allSat, Looking for solution 1982-[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 s71)-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 s68)-[GOOD] (assert s84)-Fast allSat, Looking for solution 1983-[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 s71)-Fast allSat, Looking for solution 1984-[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 s69)-Fast allSat, Looking for solution 1985-[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 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 2))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 1987-[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 s64)-Fast allSat, Looking for solution 1988-[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 s63)-Fast allSat, Looking for solution 1989-[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 s62)-Fast allSat, Looking for solution 1990-[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 s61)-Fast allSat, Looking for solution 1991-[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 s60)-Fast allSat, Looking for solution 1992-[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 s58)-Fast allSat, Looking for solution 1993-[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 s72)-Fast allSat, Looking for solution 1994-[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 s89)-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 s66)-[GOOD] (assert s98)-[GOOD] (assert s85)-Fast allSat, Looking for solution 1995-[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 s89)-Fast allSat, Looking for solution 1996-[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 s72)-Fast allSat, Looking for solution 1997-[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 s58)-Fast allSat, Looking for solution 1998-[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 s60)-Fast allSat, Looking for solution 1999-[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 s61)-Fast allSat, Looking for solution 2000-[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 s62)-Fast allSat, Looking for solution 2001-[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 s63)-Fast allSat, Looking for solution 2002-[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 s64)-Fast allSat, Looking for solution 2003-[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 s65)-Fast allSat, Looking for solution 2004-[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 s68)-Fast allSat, Looking for solution 2005-[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 s69)-Fast allSat, Looking for solution 2006-[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 s70)-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 s43)-[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 2))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s45)-Fast allSat, Looking for solution 2008-[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 s46)-Fast allSat, Looking for solution 2009-[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 6))-[GOOD] (push 1)-[GOOD] (assert s48)-Fast allSat, Looking for solution 2010-[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 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 7))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[GOOD] (push 1)-[GOOD] (assert s50)-Fast allSat, Looking for solution 2012-[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 s51)-Fast allSat, Looking for solution 2013-[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 s52)-Fast allSat, Looking for solution 2014-[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 s53)-Fast allSat, Looking for solution 2015-[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 s54)-Fast allSat, Looking for solution 2016-[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 s55)-Fast allSat, Looking for solution 2017-[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 s56)-Fast allSat, Looking for solution 2018-[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 s57)-Fast allSat, Looking for solution 2019-[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 s87)-Fast allSat, Looking for solution 2020-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s72)-[GOOD] (assert s88)-Fast allSat, Looking for solution 2020-[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 s58)-Fast allSat, Looking for solution 2021-[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 s60)-Fast allSat, Looking for solution 2022-[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 s61)-Fast allSat, Looking for solution 2023-[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 s62)-Fast allSat, Looking for solution 2024-[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 s63)-Fast allSat, Looking for solution 2025-[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 s64)-Fast allSat, Looking for solution 2026-[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 s65)-Fast allSat, Looking for solution 2027-[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 s66)-Fast allSat, Looking for solution 2028-[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 s67)-Fast allSat, Looking for solution 2029-[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 s69)-Fast allSat, Looking for solution 2030-[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 s70)-Fast allSat, Looking for solution 2031-[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 s71)-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 s89)-[GOOD] (assert s59)-Fast allSat, Looking for solution 2032-[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 s69)-Fast allSat, Looking for solution 2033-[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 s70)-Fast allSat, Looking for solution 2034-[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 s71)-Fast allSat, Looking for solution 2035-[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 s67)-Fast allSat, Looking for solution 2036-[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 s66)-Fast allSat, Looking for solution 2037-[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 s65)-Fast allSat, Looking for solution 2038-[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 s64)-Fast allSat, Looking for solution 2039-[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 s63)-Fast allSat, Looking for solution 2040-[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 s62)-Fast allSat, Looking for solution 2041-[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 s61)-Fast allSat, Looking for solution 2042-[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 s60)-Fast allSat, Looking for solution 2043-[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 s58)-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 s72)-[GOOD] (assert s73)-Fast allSat, Looking for solution 2044-[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 s60)-Fast allSat, Looking for solution 2045-[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 s61)-Fast allSat, Looking for solution 2046-[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 s62)-Fast allSat, Looking for solution 2047-[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 s63)-Fast allSat, Looking for solution 2048-[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 s64)-Fast allSat, Looking for solution 2049-[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 s65)-Fast allSat, Looking for solution 2050-[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 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 13))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 2052-[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 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 13))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[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 13))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[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 13))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s89)-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 s58)-[GOOD] (assert s74)-Fast allSat, Looking for solution 2056-[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 s89)-Fast allSat, Looking for solution 2057-[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 s72)-Fast allSat, Looking for solution 2058-[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 s61)-Fast allSat, Looking for solution 2059-[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 s62)-Fast allSat, Looking for solution 2060-[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 s63)-Fast allSat, Looking for solution 2061-[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 s64)-Fast allSat, Looking for solution 2062-[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 s65)-Fast allSat, Looking for solution 2063-[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 s66)-Fast allSat, Looking for solution 2064-[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 s67)-Fast allSat, Looking for solution 2065-[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 s69)-Fast allSat, Looking for solution 2066-[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 s70)-Fast allSat, Looking for solution 2067-[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 s71)-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 s60)-[GOOD] (assert s75)-Fast allSat, Looking for solution 2068-[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 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 11))-[SEND] (get-value (s2))-[RECV] ((s2 2))-[GOOD] (push 1)-[GOOD] (assert s70)-Fast allSat, Looking for solution 2070-[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 s71)-Fast allSat, Looking for solution 2071-[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 s67)-Fast allSat, Looking for solution 2072-[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 s66)-Fast allSat, Looking for solution 2073-[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 s65)-Fast allSat, Looking for solution 2074-[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 s64)-Fast allSat, Looking for solution 2075-[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 s63)-Fast allSat, Looking for solution 2076-[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 s62)-Fast allSat, Looking for solution 2077-[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 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 11))-[SEND] (get-value (s2))-[RECV] ((s2 14))-[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 11))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s89)-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 s61)-[GOOD] (assert s76)-Fast allSat, Looking for solution 2080-[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 s89)-Fast allSat, Looking for solution 2081-[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 s72)-Fast allSat, Looking for solution 2082-[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 s58)-Fast allSat, Looking for solution 2083-[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 s60)-Fast allSat, Looking for solution 2084-[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 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 10))-[SEND] (get-value (s2))-[RECV] ((s2 8))-[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 10))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[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 10))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[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 10))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[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 10))-[SEND] (get-value (s2))-[RECV] ((s2 3))-[GOOD] (push 1)-[GOOD] (assert s69)-Fast allSat, Looking for solution 2090-[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 s70)-Fast allSat, Looking for solution 2091-[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 s71)-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 s62)-[GOOD] (assert s77)-Fast allSat, Looking for solution 2092-[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 s69)-Fast allSat, Looking for solution 2093-[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 s70)-Fast allSat, Looking for solution 2094-[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 s71)-Fast allSat, Looking for solution 2095-[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 s67)-Fast allSat, Looking for solution 2096-[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 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 9))-[SEND] (get-value (s2))-[RECV] ((s2 7))-[GOOD] (push 1)-[GOOD] (assert s65)-Fast allSat, Looking for solution 2098-[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 s64)-Fast allSat, Looking for solution 2099-[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 s61)-Fast allSat, Looking for solution 2100-[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 s60)-Fast allSat, Looking for solution 2101-[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 s58)-Fast allSat, Looking for solution 2102-[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 s72)-Fast allSat, Looking for solution 2103-[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 s89)-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 s63)-[GOOD] (assert s78)-Fast allSat, Looking for solution 2104-[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 s89)-Fast allSat, Looking for solution 2105-[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 s72)-Fast allSat, Looking for solution 2106-[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 s58)-Fast allSat, Looking for solution 2107-[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 s60)-Fast allSat, Looking for solution 2108-[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 s61)-Fast allSat, Looking for solution 2109-[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 s62)-Fast allSat, Looking for solution 2110-[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 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 8))-[SEND] (get-value (s2))-[RECV] ((s2 6))-[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 8))-[SEND] (get-value (s2))-[RECV] ((s2 5))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 2113-[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 s69)-Fast allSat, Looking for solution 2114-[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 s70)-Fast allSat, Looking for solution 2115-[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 s71)-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 s64)-[GOOD] (assert s79)-Fast allSat, Looking for solution 2116-[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 s69)-Fast allSat, Looking for solution 2117-[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 s70)-Fast allSat, Looking for solution 2118-[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 s71)-Fast allSat, Looking for solution 2119-[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 s67)-Fast allSat, Looking for solution 2120-[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 s66)-Fast allSat, Looking for solution 2121-[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 s63)-Fast allSat, Looking for solution 2122-[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 s62)-Fast allSat, Looking for solution 2123-[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 s61)-Fast allSat, Looking for solution 2124-[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 s60)-Fast allSat, Looking for solution 2125-[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 s58)-Fast allSat, Looking for solution 2126-[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 s72)-Fast allSat, Looking for solution 2127-[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 s89)-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 6))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s89)-Fast allSat, Looking for solution 2129-[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 s72)-Fast allSat, Looking for solution 2130-[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 s58)-Fast allSat, Looking for solution 2131-[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 s60)-Fast allSat, Looking for solution 2132-[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 s61)-Fast allSat, Looking for solution 2133-[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 s62)-Fast allSat, Looking for solution 2134-[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 s63)-Fast allSat, Looking for solution 2135-[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 s64)-Fast allSat, Looking for solution 2136-[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 s67)-Fast allSat, Looking for solution 2137-[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 s69)-Fast allSat, Looking for solution 2138-[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 s70)-Fast allSat, Looking for solution 2139-[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 s71)-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 s66)-[GOOD] (assert s81)-Fast allSat, Looking for solution 2140-[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 s69)-Fast allSat, Looking for solution 2141-[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 s70)-Fast allSat, Looking for solution 2142-[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 s71)-Fast allSat, Looking for solution 2143-[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 s65)-Fast allSat, Looking for solution 2144-[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 s64)-Fast allSat, Looking for solution 2145-[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 s63)-Fast allSat, Looking for solution 2146-[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 s62)-Fast allSat, Looking for solution 2147-[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 s61)-Fast allSat, Looking for solution 2148-[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 s60)-Fast allSat, Looking for solution 2149-[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 s58)-Fast allSat, Looking for solution 2150-[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 s72)-Fast allSat, Looking for solution 2151-[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 s89)-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 s67)-[GOOD] (assert s83)-Fast allSat, Looking for solution 2152-[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 s89)-Fast allSat, Looking for solution 2153-[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 s72)-Fast allSat, Looking for solution 2154-[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 s58)-Fast allSat, Looking for solution 2155-[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 s60)-Fast allSat, Looking for solution 2156-[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 s61)-Fast allSat, Looking for solution 2157-[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 s62)-Fast allSat, Looking for solution 2158-[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 s63)-Fast allSat, Looking for solution 2159-[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 s64)-Fast allSat, Looking for solution 2160-[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 s65)-Fast allSat, Looking for solution 2161-[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 s66)-Fast allSat, Looking for solution 2162-[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 s70)-Fast allSat, Looking for solution 2163-[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 s71)-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 s69)-[GOOD] (assert s84)-Fast allSat, Looking for solution 2164-[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 s71)-Fast allSat, Looking for solution 2165-[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 s67)-Fast allSat, Looking for solution 2166-[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 s66)-Fast allSat, Looking for solution 2167-[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 s65)-Fast allSat, Looking for solution 2168-[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 s64)-Fast allSat, Looking for solution 2169-[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 s63)-Fast allSat, Looking for solution 2170-[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 s62)-Fast allSat, Looking for solution 2171-[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 s61)-Fast allSat, Looking for solution 2172-[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 s60)-Fast allSat, Looking for solution 2173-[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 s58)-Fast allSat, Looking for solution 2174-[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 s72)-Fast allSat, Looking for solution 2175-[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 s89)-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 s67)-[GOOD] (assert s99)-[GOOD] (assert s85)-Fast allSat, Looking for solution 2176-[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 s89)-Fast allSat, Looking for solution 2177-[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 s72)-Fast allSat, Looking for solution 2178-[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 s58)-Fast allSat, Looking for solution 2179-[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 s60)-Fast allSat, Looking for solution 2180-[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 s61)-Fast allSat, Looking for solution 2181-[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 s62)-Fast allSat, Looking for solution 2182-[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 s63)-Fast allSat, Looking for solution 2183-[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 s64)-Fast allSat, Looking for solution 2184-[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 s65)-Fast allSat, Looking for solution 2185-[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 s66)-Fast allSat, Looking for solution 2186-[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 s69)-Fast allSat, Looking for solution 2187-[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 s70)-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 s43)-[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 2))-[SEND] (get-value (s1))-[RECV] ((s1 3))-[SEND] (get-value (s2))-[RECV] ((s2 1))-[GOOD] (push 1)-[GOOD] (assert s46)-Fast allSat, Looking for solution 2189-[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 s47)-Fast allSat, Looking for solution 2190-[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 s48)-Fast allSat, Looking for solution 2191-[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 s49)-Fast allSat, Looking for solution 2192-[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 s50)-Fast allSat, Looking for solution 2193-[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 s51)-Fast allSat, Looking for solution 2194-[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 s52)-Fast allSat, Looking for solution 2195-[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 s53)-Fast allSat, Looking for solution 2196-[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 s54)-Fast allSat, Looking for solution 2197-[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 s55)-Fast allSat, Looking for solution 2198-[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 s56)-Fast allSat, Looking for solution 2199-[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 s57)-Fast allSat, Looking for solution 2200-[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 s87)-Fast allSat, Looking for solution 2201-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s71)-[GOOD] (assert s88)-Fast allSat, Looking for solution 2201-[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 s69)-Fast allSat, Looking for solution 2202-[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 s68)-Fast allSat, Looking for solution 2203-[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 s67)-Fast allSat, Looking for solution 2204-[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 s66)-Fast allSat, Looking for solution 2205-[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 s65)-Fast allSat, Looking for solution 2206-[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 s64)-Fast allSat, Looking for solution 2207-[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 s63)-Fast allSat, Looking for solution 2208-[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 s62)-Fast allSat, Looking for solution 2209-[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 s61)-Fast allSat, Looking for solution 2210-[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 s60)-Fast allSat, Looking for solution 2211-[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 s58)-Fast allSat, Looking for solution 2212-[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 s72)-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 s71)-[GOOD] (assert s59)-Fast allSat, Looking for solution 2213-[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 s58)-Fast allSat, Looking for solution 2214-[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 s60)-Fast allSat, Looking for solution 2215-[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 s61)-Fast allSat, Looking for solution 2216-[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 s62)-Fast allSat, Looking for solution 2217-[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 s63)-Fast allSat, Looking for solution 2218-[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 s64)-Fast allSat, Looking for solution 2219-[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 s65)-Fast allSat, Looking for solution 2220-[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 s66)-Fast allSat, Looking for solution 2221-[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 s67)-Fast allSat, Looking for solution 2222-[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 s68)-Fast allSat, Looking for solution 2223-[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 s69)-Fast allSat, Looking for solution 2224-[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 s89)-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 s73)-Fast allSat, Looking for solution 2225-[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 s72)-Fast allSat, Looking for solution 2226-[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 s89)-Fast allSat, Looking for solution 2227-[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 s60)-Fast allSat, Looking for solution 2228-[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 s61)-Fast allSat, Looking for solution 2229-[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 s62)-Fast allSat, Looking for solution 2230-[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 s63)-Fast allSat, Looking for solution 2231-[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 s64)-Fast allSat, Looking for solution 2232-[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 s65)-Fast allSat, Looking for solution 2233-[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 s66)-Fast allSat, Looking for solution 2234-[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 s67)-Fast allSat, Looking for solution 2235-[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 s68)-Fast allSat, Looking for solution 2236-[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 s69)-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 s71)-[GOOD] (assert s74)-Fast allSat, Looking for solution 2237-[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 s61)-Fast allSat, Looking for solution 2238-[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 s62)-Fast allSat, Looking for solution 2239-[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 s63)-Fast allSat, Looking for solution 2240-[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 s64)-Fast allSat, Looking for solution 2241-[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 s65)-Fast allSat, Looking for solution 2242-[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 s66)-Fast allSat, Looking for solution 2243-[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 s67)-Fast allSat, Looking for solution 2244-[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 s68)-Fast allSat, Looking for solution 2245-[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 s69)-Fast allSat, Looking for solution 2246-[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 s58)-Fast allSat, Looking for solution 2247-[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 s72)-Fast allSat, Looking for solution 2248-[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 s89)-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 s75)-Fast allSat, Looking for solution 2249-[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 s89)-Fast allSat, Looking for solution 2250-[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 s72)-Fast allSat, Looking for solution 2251-[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 s58)-Fast allSat, Looking for solution 2252-[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 s60)-Fast allSat, Looking for solution 2253-[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 s62)-Fast allSat, Looking for solution 2254-[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 s63)-Fast allSat, Looking for solution 2255-[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 s64)-Fast allSat, Looking for solution 2256-[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 s65)-Fast allSat, Looking for solution 2257-[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 s66)-Fast allSat, Looking for solution 2258-[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 s67)-Fast allSat, Looking for solution 2259-[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 s68)-Fast allSat, Looking for solution 2260-[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 s69)-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 s71)-[GOOD] (assert s76)-Fast allSat, Looking for solution 2261-[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 s63)-Fast allSat, Looking for solution 2262-[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 s64)-Fast allSat, Looking for solution 2263-[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 s65)-Fast allSat, Looking for solution 2264-[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 s66)-Fast allSat, Looking for solution 2265-[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 s67)-Fast allSat, Looking for solution 2266-[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 s68)-Fast allSat, Looking for solution 2267-[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 s69)-Fast allSat, Looking for solution 2268-[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 s61)-Fast allSat, Looking for solution 2269-[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 s60)-Fast allSat, Looking for solution 2270-[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 s58)-Fast allSat, Looking for solution 2271-[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 s72)-Fast allSat, Looking for solution 2272-[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 s89)-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 s71)-[GOOD] (assert s77)-Fast allSat, Looking for solution 2273-[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 s89)-Fast allSat, Looking for solution 2274-[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 s72)-Fast allSat, Looking for solution 2275-[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 s58)-Fast allSat, Looking for solution 2276-[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 s60)-Fast allSat, Looking for solution 2277-[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 s61)-Fast allSat, Looking for solution 2278-[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 s62)-Fast allSat, Looking for solution 2279-[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 s64)-Fast allSat, Looking for solution 2280-[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 s65)-Fast allSat, Looking for solution 2281-[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 s66)-Fast allSat, Looking for solution 2282-[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 s67)-Fast allSat, Looking for solution 2283-[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 s68)-Fast allSat, Looking for solution 2284-[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 s69)-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 s71)-[GOOD] (assert s78)-Fast allSat, Looking for solution 2285-[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 s65)-Fast allSat, Looking for solution 2286-[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 s66)-Fast allSat, Looking for solution 2287-[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 s67)-Fast allSat, Looking for solution 2288-[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 s68)-Fast allSat, Looking for solution 2289-[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 s69)-Fast allSat, Looking for solution 2290-[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 s63)-Fast allSat, Looking for solution 2291-[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 s62)-Fast allSat, Looking for solution 2292-[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 s61)-Fast allSat, Looking for solution 2293-[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 s60)-Fast allSat, Looking for solution 2294-[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 s58)-Fast allSat, Looking for solution 2295-[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 s72)-Fast allSat, Looking for solution 2296-[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 s89)-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 s71)-[GOOD] (assert s79)-Fast allSat, Looking for solution 2297-[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 s89)-Fast allSat, Looking for solution 2298-[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 s72)-Fast allSat, Looking for solution 2299-[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 s58)-Fast allSat, Looking for solution 2300-[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 s60)-Fast allSat, Looking for solution 2301-[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 s61)-Fast allSat, Looking for solution 2302-[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 s62)-Fast allSat, Looking for solution 2303-[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 s63)-Fast allSat, Looking for solution 2304-[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 s64)-Fast allSat, Looking for solution 2305-[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 s66)-Fast allSat, Looking for solution 2306-[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 s67)-Fast allSat, Looking for solution 2307-[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 s68)-Fast allSat, Looking for solution 2308-[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 s69)-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 s71)-[GOOD] (assert s80)-Fast allSat, Looking for solution 2309-[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 s67)-Fast allSat, Looking for solution 2310-[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 s68)-Fast allSat, Looking for solution 2311-[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 s69)-Fast allSat, Looking for solution 2312-[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 s65)-Fast allSat, Looking for solution 2313-[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 s64)-Fast allSat, Looking for solution 2314-[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 s63)-Fast allSat, Looking for solution 2315-[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 s62)-Fast allSat, Looking for solution 2316-[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 s61)-Fast allSat, Looking for solution 2317-[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 s60)-Fast allSat, Looking for solution 2318-[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 s58)-Fast allSat, Looking for solution 2319-[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 s72)-Fast allSat, Looking for solution 2320-[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 s89)-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 s71)-[GOOD] (assert s81)-Fast allSat, Looking for solution 2321-[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 s89)-Fast allSat, Looking for solution 2322-[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 s72)-Fast allSat, Looking for solution 2323-[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 s58)-Fast allSat, Looking for solution 2324-[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 s60)-Fast allSat, Looking for solution 2325-[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 s61)-Fast allSat, Looking for solution 2326-[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 s62)-Fast allSat, Looking for solution 2327-[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 s63)-Fast allSat, Looking for solution 2328-[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 s64)-Fast allSat, Looking for solution 2329-[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 s65)-Fast allSat, Looking for solution 2330-[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 s66)-Fast allSat, Looking for solution 2331-[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 s68)-Fast allSat, Looking for solution 2332-[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 s69)-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 s71)-[GOOD] (assert s82)-Fast allSat, Looking for solution 2333-[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 s69)-Fast allSat, Looking for solution 2334-[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 s67)-Fast allSat, Looking for solution 2335-[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 s66)-Fast allSat, Looking for solution 2336-[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 s65)-Fast allSat, Looking for solution 2337-[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 s64)-Fast allSat, Looking for solution 2338-[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 s63)-Fast allSat, Looking for solution 2339-[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 s62)-Fast allSat, Looking for solution 2340-[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 s61)-Fast allSat, Looking for solution 2341-[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 s60)-Fast allSat, Looking for solution 2342-[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 s58)-Fast allSat, Looking for solution 2343-[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 s72)-Fast allSat, Looking for solution 2344-[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 s89)-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 s71)-[GOOD] (assert s83)-Fast allSat, Looking for solution 2345-[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 s89)-Fast allSat, Looking for solution 2346-[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 s72)-Fast allSat, Looking for solution 2347-[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 s58)-Fast allSat, Looking for solution 2348-[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 s60)-Fast allSat, Looking for solution 2349-[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 s61)-Fast allSat, Looking for solution 2350-[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 s62)-Fast allSat, Looking for solution 2351-[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 s63)-Fast allSat, Looking for solution 2352-[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 s64)-Fast allSat, Looking for solution 2353-[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 s65)-Fast allSat, Looking for solution 2354-[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 s66)-Fast allSat, Looking for solution 2355-[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 s67)-Fast allSat, Looking for solution 2356-[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 4))-[GOOD] (push 1)-[GOOD] (assert s68)-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 s69)-[GOOD] (assert s100)-[GOOD] (assert s85)-Fast allSat, Looking for solution 2357-[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 s68)-Fast allSat, Looking for solution 2358-[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 s67)-Fast allSat, Looking for solution 2359-[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 s66)-Fast allSat, Looking for solution 2360-[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 s65)-Fast allSat, Looking for solution 2361-[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 s64)-Fast allSat, Looking for solution 2362-[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 s63)-Fast allSat, Looking for solution 2363-[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 s62)-Fast allSat, Looking for solution 2364-[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 s61)-Fast allSat, Looking for solution 2365-[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 s60)-Fast allSat, Looking for solution 2366-[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 s58)-Fast allSat, Looking for solution 2367-[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 s72)-Fast allSat, Looking for solution 2368-[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 s89)-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 s43)-[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 3))-[SEND] (get-value (s1))-[RECV] ((s1 2))-[SEND] (get-value (s2))-[RECV] ((s2 15))-[GOOD] (push 1)-[GOOD] (assert s45)-Fast allSat, Looking for solution 2370-[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 s47)-Fast allSat, Looking for solution 2371-[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 s48)-Fast allSat, Looking for solution 2372-[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 s49)-Fast allSat, Looking for solution 2373-[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 s50)-Fast allSat, Looking for solution 2374-[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 s51)-Fast allSat, Looking for solution 2375-[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 s52)-Fast allSat, Looking for solution 2376-[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 s53)-Fast allSat, Looking for solution 2377-[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 s54)-Fast allSat, Looking for solution 2378-[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 s55)-Fast allSat, Looking for solution 2379-[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 s56)-Fast allSat, Looking for solution 2380-[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 s57)-Fast allSat, Looking for solution 2381-[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 s87)-Fast allSat, Looking for solution 2382-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s72)-[GOOD] (assert s88)-Fast allSat, Looking for solution 2382-[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 s58)-Fast allSat, Looking for solution 2383-[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 s60)-Fast allSat, Looking for solution 2384-[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 s61)-Fast allSat, Looking for solution 2385-[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 s62)-Fast allSat, Looking for solution 2386-[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 s63)-Fast allSat, Looking for solution 2387-[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 s64)-Fast allSat, Looking for solution 2388-[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 s65)-Fast allSat, Looking for solution 2389-[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 s66)-Fast allSat, Looking for solution 2390-[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 s67)-Fast allSat, Looking for solution 2391-[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 s68)-Fast allSat, Looking for solution 2392-[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 s70)-Fast allSat, Looking for solution 2393-[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 s71)-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 s89)-[GOOD] (assert s59)-Fast allSat, Looking for solution 2394-[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 s70)-Fast allSat, Looking for solution 2395-[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 s71)-Fast allSat, Looking for solution 2396-[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 s68)-Fast allSat, Looking for solution 2397-[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 s67)-Fast allSat, Looking for solution 2398-[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 s66)-Fast allSat, Looking for solution 2399-[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 s65)-Fast allSat, Looking for solution 2400-[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 s64)-Fast allSat, Looking for solution 2401-[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 s63)-Fast allSat, Looking for solution 2402-[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 s62)-Fast allSat, Looking for solution 2403-[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 s61)-Fast allSat, Looking for solution 2404-[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 s60)-Fast allSat, Looking for solution 2405-[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 s58)-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 s89)-[GOOD] (assert s73)-Fast allSat, Looking for solution 2406-[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 s60)-Fast allSat, Looking for solution 2407-[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 s61)-Fast allSat, Looking for solution 2408-[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 s62)-Fast allSat, Looking for solution 2409-[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 s63)-Fast allSat, Looking for solution 2410-[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 s64)-Fast allSat, Looking for solution 2411-[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 s65)-Fast allSat, Looking for solution 2412-[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 s66)-Fast allSat, Looking for solution 2413-[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 s67)-Fast allSat, Looking for solution 2414-[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 s68)-Fast allSat, Looking for solution 2415-[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 s72)-Fast allSat, Looking for solution 2416-[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 s70)-Fast allSat, Looking for solution 2417-[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 s71)-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 s89)-[GOOD] (assert s74)-Fast allSat, Looking for solution 2418-[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 s70)-Fast allSat, Looking for solution 2419-[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 s71)-Fast allSat, Looking for solution 2420-[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 s68)-Fast allSat, Looking for solution 2421-[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 s67)-Fast allSat, Looking for solution 2422-[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 s66)-Fast allSat, Looking for solution 2423-[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 s65)-Fast allSat, Looking for solution 2424-[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 s64)-Fast allSat, Looking for solution 2425-[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 s63)-Fast allSat, Looking for solution 2426-[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 s62)-Fast allSat, Looking for solution 2427-[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 s61)-Fast allSat, Looking for solution 2428-[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 s58)-Fast allSat, Looking for solution 2429-[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 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 s89)-[GOOD] (assert s75)-Fast allSat, Looking for solution 2430-[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 s72)-Fast allSat, Looking for solution 2431-[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 s58)-Fast allSat, Looking for solution 2432-[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 s60)-Fast allSat, Looking for solution 2433-[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 s62)-Fast allSat, Looking for solution 2434-[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 s63)-Fast allSat, Looking for solution 2435-[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 s64)-Fast allSat, Looking for solution 2436-[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 s65)-Fast allSat, Looking for solution 2437-[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 s66)-Fast allSat, Looking for solution 2438-[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 s67)-Fast allSat, Looking for solution 2439-[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 s68)-Fast allSat, Looking for solution 2440-[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 s70)-Fast allSat, Looking for solution 2441-[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 s71)-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 s89)-[GOOD] (assert s76)-Fast allSat, Looking for solution 2442-[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 s70)-Fast allSat, Looking for solution 2443-[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 s71)-Fast allSat, Looking for solution 2444-[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 s68)-Fast allSat, Looking for solution 2445-[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 s67)-Fast allSat, Looking for solution 2446-[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 s66)-Fast allSat, Looking for solution 2447-[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 s65)-Fast allSat, Looking for solution 2448-[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 s64)-Fast allSat, Looking for solution 2449-[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 s63)-Fast allSat, Looking for solution 2450-[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 s61)-Fast allSat, Looking for solution 2451-[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 s60)-Fast allSat, Looking for solution 2452-[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 s58)-Fast allSat, Looking for solution 2453-[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 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 s89)-[GOOD] (assert s77)-Fast allSat, Looking for solution 2454-[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 s72)-Fast allSat, Looking for solution 2455-[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 s58)-Fast allSat, Looking for solution 2456-[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 s60)-Fast allSat, Looking for solution 2457-[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 s61)-Fast allSat, Looking for solution 2458-[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 s62)-Fast allSat, Looking for solution 2459-[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 s64)-Fast allSat, Looking for solution 2460-[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 s65)-Fast allSat, Looking for solution 2461-[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 s66)-Fast allSat, Looking for solution 2462-[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 s67)-Fast allSat, Looking for solution 2463-[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 s68)-Fast allSat, Looking for solution 2464-[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 s70)-Fast allSat, Looking for solution 2465-[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 s71)-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 s89)-[GOOD] (assert s78)-Fast allSat, Looking for solution 2466-[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 s70)-Fast allSat, Looking for solution 2467-[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 s71)-Fast allSat, Looking for solution 2468-[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 s68)-Fast allSat, Looking for solution 2469-[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 s67)-Fast allSat, Looking for solution 2470-[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 s66)-Fast allSat, Looking for solution 2471-[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 s65)-Fast allSat, Looking for solution 2472-[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 s63)-Fast allSat, Looking for solution 2473-[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 s62)-Fast allSat, Looking for solution 2474-[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 s61)-Fast allSat, Looking for solution 2475-[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 s60)-Fast allSat, Looking for solution 2476-[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 s58)-Fast allSat, Looking for solution 2477-[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 s72)-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 s89)-[GOOD] (assert s79)-Fast allSat, Looking for solution 2478-[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 s72)-Fast allSat, Looking for solution 2479-[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 s58)-Fast allSat, Looking for solution 2480-[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 s60)-Fast allSat, Looking for solution 2481-[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 s61)-Fast allSat, Looking for solution 2482-[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 s62)-Fast allSat, Looking for solution 2483-[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 s63)-Fast allSat, Looking for solution 2484-[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 s64)-Fast allSat, Looking for solution 2485-[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 s66)-Fast allSat, Looking for solution 2486-[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 s67)-Fast allSat, Looking for solution 2487-[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 s68)-Fast allSat, Looking for solution 2488-[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 s70)-Fast allSat, Looking for solution 2489-[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 s71)-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 s89)-[GOOD] (assert s80)-Fast allSat, Looking for solution 2490-[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 s70)-Fast allSat, Looking for solution 2491-[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 s71)-Fast allSat, Looking for solution 2492-[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 s68)-Fast allSat, Looking for solution 2493-[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 s67)-Fast allSat, Looking for solution 2494-[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 s65)-Fast allSat, Looking for solution 2495-[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 s64)-Fast allSat, Looking for solution 2496-[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 s63)-Fast allSat, Looking for solution 2497-[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 s62)-Fast allSat, Looking for solution 2498-[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 s61)-Fast allSat, Looking for solution 2499-[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 s60)-Fast allSat, Looking for solution 2500-[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 s58)-Fast allSat, Looking for solution 2501-[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 s72)-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 s89)-[GOOD] (assert s81)-Fast allSat, Looking for solution 2502-[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 s72)-Fast allSat, Looking for solution 2503-[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 s58)-Fast allSat, Looking for solution 2504-[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 s60)-Fast allSat, Looking for solution 2505-[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 s61)-Fast allSat, Looking for solution 2506-[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 s62)-Fast allSat, Looking for solution 2507-[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 s63)-Fast allSat, Looking for solution 2508-[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 s64)-Fast allSat, Looking for solution 2509-[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 s65)-Fast allSat, Looking for solution 2510-[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 s66)-Fast allSat, Looking for solution 2511-[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 s68)-Fast allSat, Looking for solution 2512-[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 s70)-Fast allSat, Looking for solution 2513-[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 s71)-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 s89)-[GOOD] (assert s82)-Fast allSat, Looking for solution 2514-[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 s70)-Fast allSat, Looking for solution 2515-[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 s71)-Fast allSat, Looking for solution 2516-[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 5))-[GOOD] (push 1)-[GOOD] (assert s67)-Fast allSat, Looking for solution 2517-[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 s66)-Fast allSat, Looking for solution 2518-[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 s65)-Fast allSat, Looking for solution 2519-[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 s64)-Fast allSat, Looking for solution 2520-[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 s63)-Fast allSat, Looking for solution 2521-[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 s62)-Fast allSat, Looking for solution 2522-[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 s61)-Fast allSat, Looking for solution 2523-[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 s60)-Fast allSat, Looking for solution 2524-[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 s58)-Fast allSat, Looking for solution 2525-[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 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 s89)-[GOOD] (assert s84)-Fast allSat, Looking for solution 2526-[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 s72)-Fast allSat, Looking for solution 2527-[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 s58)-Fast allSat, Looking for solution 2528-[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 s60)-Fast allSat, Looking for solution 2529-[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 s61)-Fast allSat, Looking for solution 2530-[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 s62)-Fast allSat, Looking for solution 2531-[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 s63)-Fast allSat, Looking for solution 2532-[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 s64)-Fast allSat, Looking for solution 2533-[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 s65)-Fast allSat, Looking for solution 2534-[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 s66)-Fast allSat, Looking for solution 2535-[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 s67)-Fast allSat, Looking for solution 2536-[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 s68)-Fast allSat, Looking for solution 2537-[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 s71)-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 s70)-[GOOD] (assert s101)-[GOOD] (assert s85)-Fast allSat, Looking for solution 2538-[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 s68)-Fast allSat, Looking for solution 2539-[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 s67)-Fast allSat, Looking for solution 2540-[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 s66)-Fast allSat, Looking for solution 2541-[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 s65)-Fast allSat, Looking for solution 2542-[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 s64)-Fast allSat, Looking for solution 2543-[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 s63)-Fast allSat, Looking for solution 2544-[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 s62)-Fast allSat, Looking for solution 2545-[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 s61)-Fast allSat, Looking for solution 2546-[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 s60)-Fast allSat, Looking for solution 2547-[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 s58)-Fast allSat, Looking for solution 2548-[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 s72)-Fast allSat, Looking for solution 2549-[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 s89)-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 s45)-[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 15))-[GOOD] (push 1)-[GOOD] (assert s46)-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 15))-[GOOD] (push 1)-[GOOD] (assert s47)-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 15))-[GOOD] (push 1)-[GOOD] (assert s48)-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 15))-[GOOD] (push 1)-[GOOD] (assert s49)-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 15))-[GOOD] (push 1)-[GOOD] (assert s50)-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 15))-[GOOD] (push 1)-[GOOD] (assert s51)-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 15))-[GOOD] (push 1)-[GOOD] (assert s52)-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 15))-[GOOD] (push 1)-[GOOD] (assert s53)-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 15))-[GOOD] (push 1)-[GOOD] (assert s54)-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 15))-[GOOD] (push 1)-[GOOD] (assert s55)-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 15))-[GOOD] (push 1)-[GOOD] (assert s56)-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 s57)-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 s87)-Fast allSat, Looking for solution 2563-[SEND] (check-sat)-[RECV] unsat-[GOOD] (pop 1)-[GOOD] (push 1)-[GOOD] (assert s72)-[GOOD] (assert s88)-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 s58)-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 s60)-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 s61)-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 s62)-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 s63)-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 s64)-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 s65)-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 s66)-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 s67)-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 s68)-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 s69)-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 s70)-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 s89)-[GOOD] (assert s59)-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 s70)-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 s69)-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 s68)-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 s67)-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 s66)-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 s65)-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 s64)-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 s63)-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 s62)-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 s61)-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 s60)-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 s58)-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 s89)-[GOOD] (assert s73)-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 5))-[GOOD] (push 1)-[GOOD] (assert s67)-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 6))-[GOOD] (push 1)-[GOOD] (assert s66)-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 s65)-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 8))-[GOOD] (push 1)-[GOOD] (assert s64)-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 9))-[GOOD] (push 1)-[GOOD] (assert s63)-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 10))-[GOOD] (push 1)-[GOOD] (assert s62)-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 11))-[GOOD] (push 1)-[GOOD] (assert s61)-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 12))-[GOOD] (push 1)-[GOOD] (assert s60)-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 s68)-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 s69)-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 2))-[GOOD] (push 1)-[GOOD] (assert s70)-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 14))-[GOOD] (push 1)-[GOOD] (assert s72)-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 s89)-[GOOD] (assert s74)-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 7))-[GOOD] (push 1)-[GOOD] (assert s65)-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 8))-[GOOD] (push 1)-[GOOD] (assert s64)-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 s63)-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 10))-[GOOD] (push 1)-[GOOD] (assert s62)-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 11))-[GOOD] (push 1)-[GOOD] (assert s61)-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 s66)-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 s67)-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 s68)-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 s69)-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 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 13))-[GOOD] (push 1)-[GOOD] (assert s58)-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 14))-[GOOD] (push 1)-[GOOD] (assert s72)-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 s89)-[GOOD] (assert s75)-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 14))-[GOOD] (push 1)-[GOOD] (assert s72)-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 13))-[GOOD] (push 1)-[GOOD] (assert s58)-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 12))-[GOOD] (push 1)-[GOOD] (assert s60)-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 10))-[GOOD] (push 1)-[GOOD] (assert s62)-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 9))-[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 8))-[GOOD] (push 1)-[GOOD] (assert s64)-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 7))-[GOOD] (push 1)-[GOOD] (assert s65)-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 6))-[GOOD] (push 1)-[GOOD] (assert s66)-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 5))-[GOOD] (push 1)-[GOOD] (assert s67)-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 4))-[GOOD] (push 1)-[GOOD] (assert s68)-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 3))-[GOOD] (push 1)-[GOOD] (assert s69)-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 2))-[GOOD] (push 1)-[GOOD] (assert s70)-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 s89)-[GOOD] (assert s76)-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 s63)-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 s64)-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 s65)-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 s66)-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 s67)-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 s68)-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 s69)-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 2))-[GOOD] (push 1)-[GOOD] (assert s70)-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 11))-[GOOD] (push 1)-[GOOD] (assert s61)-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 12))-[GOOD] (push 1)-[GOOD] (assert s60)-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 13))-[GOOD] (push 1)-[GOOD] (assert s58)-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 14))-[GOOD] (push 1)-[GOOD] (assert s72)-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 s89)-[GOOD] (assert s77)-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 14))-[GOOD] (push 1)-[GOOD] (assert s72)-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 13))-[GOOD] (push 1)-[GOOD] (assert s58)-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 12))-[GOOD] (push 1)-[GOOD] (assert s60)-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 11))-[GOOD] (push 1)-[GOOD] (assert s61)-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 10))-[GOOD] (push 1)-[GOOD] (assert s62)-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 8))-[GOOD] (push 1)-[GOOD] (assert s64)-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 7))-[GOOD] (push 1)-[GOOD] (assert s65)-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 6))-[GOOD] (push 1)-[GOOD] (assert s66)-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 5))-[GOOD] (push 1)-[GOOD] (assert s67)-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 4))-[GOOD] (push 1)-[GOOD] (assert s68)-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 3))-[GOOD] (push 1)-[GOOD] (assert s69)-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 2))-[GOOD] (push 1)-[GOOD] (assert s70)-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 s89)-[GOOD] (assert s78)-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 s65)-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 s66)-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 s67)-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 s68)-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 s69)-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 2))-[GOOD] (push 1)-[GOOD] (assert s70)-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 9))-[GOOD] (push 1)-[GOOD] (assert s63)-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 10))-[GOOD] (push 1)-[GOOD] (assert s62)-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 11))-[GOOD] (push 1)-[GOOD] (assert s61)-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 12))-[GOOD] (push 1)-[GOOD] (assert s60)-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 13))-[GOOD] (push 1)-[GOOD] (assert s58)-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 14))-[GOOD] (push 1)-[GOOD] (assert s72)-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 s89)-[GOOD] (assert s79)-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 14))-[GOOD] (push 1)-[GOOD] (assert s72)-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 13))-[GOOD] (push 1)-[GOOD] (assert s58)-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 12))-[GOOD] (push 1)-[GOOD] (assert s60)-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 11))-[GOOD] (push 1)-[GOOD] (assert s61)-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 10))-[GOOD] (push 1)-[GOOD] (assert s62)-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 s63)-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 8))-[GOOD] (push 1)-[GOOD] (assert s64)-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 6))-[GOOD] (push 1)-[GOOD] (assert s66)-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 5))-[GOOD] (push 1)-[GOOD] (assert s67)-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 4))-[GOOD] (push 1)-[GOOD] (assert s68)-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 3))-[GOOD] (push 1)-[GOOD] (assert s69)-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 2))-[GOOD] (push 1)-[GOOD] (assert s70)-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 s89)-[GOOD] (assert s80)-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 s67)-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 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 3))-[GOOD] (push 1)-[GOOD] (assert s69)-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 2))-[GOOD] (push 1)-[GOOD] (assert s70)-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 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 8))-[GOOD] (push 1)-[GOOD] (assert s64)-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 9))-[GOOD] (push 1)-[GOOD] (assert s63)-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 10))-[GOOD] (push 1)-[GOOD] (assert s62)-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 11))-[GOOD] (push 1)-[GOOD] (assert s61)-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 12))-[GOOD] (push 1)-[GOOD] (assert s60)-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 13))-[GOOD] (push 1)-[GOOD] (assert s58)-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 14))-[GOOD] (push 1)-[GOOD] (assert s72)-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 s89)-[GOOD] (assert s81)-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 14))-[GOOD] (push 1)-[GOOD] (assert s72)-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 13))-[GOOD] (push 1)-[GOOD] (assert s58)-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 12))-[GOOD] (push 1)-[GOOD] (assert s60)-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 11))-[GOOD] (push 1)-[GOOD] (assert s61)-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 10))-[GOOD] (push 1)-[GOOD] (assert s62)-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 s63)-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 8))-[GOOD] (push 1)-[GOOD] (assert s64)-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 7))-[GOOD] (push 1)-[GOOD] (assert s65)-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 6))-[GOOD] (push 1)-[GOOD] (assert s66)-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 4))-[GOOD] (push 1)-[GOOD] (assert s68)-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 3))-[GOOD] (push 1)-[GOOD] (assert s69)-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 2))-[GOOD] (push 1)-[GOOD] (assert s70)-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 s89)-[GOOD] (assert s82)-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 s69)-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 2))-[GOOD] (push 1)-[GOOD] (assert s70)-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 5))-[GOOD] (push 1)-[GOOD] (assert s67)-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 6))-[GOOD] (push 1)-[GOOD] (assert s66)-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 7))-[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 8))-[GOOD] (push 1)-[GOOD] (assert s64)-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 9))-[GOOD] (push 1)-[GOOD] (assert s63)-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 10))-[GOOD] (push 1)-[GOOD] (assert s62)-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 11))-[GOOD] (push 1)-[GOOD] (assert s61)-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 12))-[GOOD] (push 1)-[GOOD] (assert s60)-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 13))-[GOOD] (push 1)-[GOOD] (assert s58)-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 14))-[GOOD] (push 1)-[GOOD] (assert s72)-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 s89)-[GOOD] (assert s83)-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 s70)-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 4))-[GOOD] (push 1)-[GOOD] (assert s68)-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 5))-[GOOD] (push 1)-[GOOD] (assert s67)-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 6))-[GOOD] (push 1)-[GOOD] (assert s66)-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 7))-[GOOD] (push 1)-[GOOD] (assert s65)-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 8))-[GOOD] (push 1)-[GOOD] (assert s64)-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 9))-[GOOD] (push 1)-[GOOD] (assert s63)-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 10))-[GOOD] (push 1)-[GOOD] (assert s62)-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 11))-[GOOD] (push 1)-[GOOD] (assert s61)-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 12))-[GOOD] (push 1)-[GOOD] (assert s60)-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 13))-[GOOD] (push 1)-[GOOD] (assert s58)-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 14))-[GOOD] (push 1)-[GOOD] (assert s72)-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 s69)-[GOOD] (assert s102)-[GOOD] (assert s84)+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (define-fun s20 () Int 4)+[GOOD] (define-fun s21 () Bool (distinct s0 s20))+[GOOD] (assert s21)+Fast allSat, Looking for solution 5+[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] (define-fun s22 () Int 5)+[GOOD] (define-fun s23 () Bool (distinct s0 s22))+[GOOD] (assert s23)+Fast allSat, Looking for solution 6+[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] (define-fun s24 () Int 6)+[GOOD] (define-fun s25 () Bool (distinct s0 s24))+[GOOD] (assert s25)+Fast allSat, Looking for solution 7+[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] (define-fun s26 () Int 7)+[GOOD] (define-fun s27 () Bool (distinct s0 s26))+[GOOD] (assert s27)+Fast allSat, Looking for solution 8+[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] (define-fun s28 () Int 8)+[GOOD] (define-fun s29 () Bool (distinct s0 s28))+[GOOD] (assert s29)+Fast allSat, Looking for solution 9+[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] (define-fun s30 () Int 9)+[GOOD] (define-fun s31 () Bool (distinct s0 s30))+[GOOD] (assert s31)+Fast allSat, Looking for solution 10+[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] (define-fun s32 () Int 10)+[GOOD] (define-fun s33 () Bool (distinct s0 s32))+[GOOD] (assert s33)+Fast allSat, Looking for solution 11+[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] (define-fun s34 () Int 11)+[GOOD] (define-fun s35 () Bool (distinct s0 s34))+[GOOD] (assert s35)+Fast allSat, Looking for solution 12+[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] (define-fun s36 () Int 12)+[GOOD] (define-fun s37 () Bool (distinct s0 s36))+[GOOD] (assert s37)+Fast allSat, Looking for solution 13+[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] (define-fun s38 () Int 13)+[GOOD] (define-fun s39 () Bool (distinct s0 s38))+[GOOD] (assert s39)+Fast allSat, Looking for solution 14+[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] (define-fun s40 () Int 14)+[GOOD] (define-fun s41 () Bool (distinct s0 s40))+[GOOD] (assert s41)+Fast allSat, Looking for solution 15+[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] (define-fun s42 () Bool (distinct s0 s5))+[GOOD] (assert s42)+Fast allSat, Looking for solution 16+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (define-fun s43 () Bool (distinct s1 s38))+[GOOD] (assert s43)+[GOOD] (define-fun s44 () Bool (= s0 s5))+[GOOD] (assert s44)+Fast allSat, Looking for solution 16+[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] (define-fun s45 () Bool (distinct s1 s36))+[GOOD] (assert s45)+Fast allSat, Looking for solution 17+[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] (define-fun s46 () Bool (distinct s1 s34))+[GOOD] (assert s46)+Fast allSat, Looking for solution 18+[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] (define-fun s47 () Bool (distinct s1 s32))+[GOOD] (assert s47)+Fast allSat, Looking for solution 19+[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] (define-fun s48 () Bool (distinct s1 s30))+[GOOD] (assert s48)+Fast allSat, Looking for solution 20+[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] (define-fun s49 () Bool (distinct s1 s28))+[GOOD] (assert s49)+Fast allSat, Looking for solution 21+[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] (define-fun s50 () Bool (distinct s1 s26))+[GOOD] (assert s50)+Fast allSat, Looking for solution 22+[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] (define-fun s51 () Bool (distinct s1 s24))+[GOOD] (assert s51)+Fast allSat, Looking for solution 23+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (define-fun s52 () Bool (distinct s1 s22))+[GOOD] (assert s52)+Fast allSat, Looking for solution 24+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (define-fun s53 () Bool (distinct s1 s20))+[GOOD] (assert s53)+Fast allSat, Looking for solution 25+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (define-fun s54 () Bool (distinct s1 s16))+[GOOD] (assert s54)+Fast allSat, Looking for solution 26+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (define-fun s55 () Bool (distinct s1 s18))+[GOOD] (assert s55)+Fast allSat, Looking for solution 27+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (define-fun s56 () Bool (distinct s1 s3))+[GOOD] (assert s56)+Fast allSat, Looking for solution 28+[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 13))+[GOOD] (push 1)+[GOOD] (define-fun s57 () Bool (distinct s1 s40))+[GOOD] (assert s57)+Fast allSat, Looking for solution 29+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (define-fun s58 () Bool (distinct s2 s38))+[GOOD] (assert s58)+[GOOD] (define-fun s59 () Bool (= s1 s40))+[GOOD] (assert s59)+Fast allSat, Looking for solution 29+[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] (define-fun s60 () Bool (distinct s2 s36))+[GOOD] (assert s60)+Fast allSat, Looking for solution 30+[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] (define-fun s61 () Bool (distinct s2 s34))+[GOOD] (assert s61)+Fast allSat, Looking for solution 31+[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] (define-fun s62 () Bool (distinct s2 s32))+[GOOD] (assert s62)+Fast allSat, Looking for solution 32+[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] (define-fun s63 () Bool (distinct s2 s30))+[GOOD] (assert s63)+Fast allSat, Looking for solution 33+[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] (define-fun s64 () Bool (distinct s2 s28))+[GOOD] (assert s64)+Fast allSat, Looking for solution 34+[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] (define-fun s65 () Bool (distinct s2 s26))+[GOOD] (assert s65)+Fast allSat, Looking for solution 35+[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] (define-fun s66 () Bool (distinct s2 s24))+[GOOD] (assert s66)+Fast allSat, Looking for solution 36+[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] (define-fun s67 () Bool (distinct s2 s22))+[GOOD] (assert s67)+Fast allSat, Looking for solution 37+[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] (define-fun s68 () Bool (distinct s2 s20))+[GOOD] (assert s68)+Fast allSat, Looking for solution 38+[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] (define-fun s69 () Bool (distinct s2 s16))+[GOOD] (assert s69)+Fast allSat, Looking for solution 39+[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] (define-fun s70 () Bool (distinct s2 s18))+[GOOD] (assert s70)+Fast allSat, Looking for solution 40+[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] (define-fun s71 () Bool (distinct s2 s3))+[GOOD] (assert s71)+Fast allSat, Looking for solution 41+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (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 s72 () Bool (distinct s2 s40))+[GOOD] (assert s72)+[GOOD] (define-fun s73 () Bool (= s1 s3))+[GOOD] (assert s73)+Fast allSat, Looking for solution 41+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 42+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 43+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 44+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 45+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 46+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 47+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 48+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 49+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 50+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 51+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 52+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 53+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 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] (define-fun s74 () Bool (= s1 s18))+[GOOD] (assert s74)+Fast allSat, Looking for solution 53+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 54+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 55+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 56+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 57+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 58+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 59+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 60+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 61+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 62+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 63+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 64+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 65+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 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] (define-fun s75 () Bool (= s1 s16))+[GOOD] (assert s75)+Fast allSat, Looking for solution 65+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 66+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 67+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 68+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 69+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 70+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 71+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 72+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 73+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 74+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 75+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 76+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 77+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 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] (define-fun s76 () Bool (= s1 s20))+[GOOD] (assert s76)+Fast allSat, Looking for solution 77+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 78+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 79+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 80+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 81+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 82+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 83+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 84+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 85+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 86+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 87+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 88+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 4))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 89+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 1)+[GOOD] (pop 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] (define-fun s77 () Bool (= s1 s22))+[GOOD] (assert s77)+Fast allSat, Looking for solution 89+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 90+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 91+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 92+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s71)+Fast allSat, Looking for solution 93+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 94+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[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 5))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 96+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 97+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 98+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 99+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 100+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 15))+[SEND] (get-value (s1))+[RECV] ((s1 5))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s58)+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 s72)+[GOOD] (define-fun s78 () Bool (= s1 s24))+[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 6))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 102+[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 s60)+Fast allSat, Looking for solution 103+[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 s61)+Fast allSat, Looking for solution 104+[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 s62)+Fast allSat, Looking for solution 105+[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 s63)+Fast allSat, Looking for solution 106+[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 s64)+Fast allSat, Looking for solution 107+[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 s65)+Fast allSat, Looking for solution 108+[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 5))+[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 6))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[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 6))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[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 6))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[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 6))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[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 s72)+[GOOD] (define-fun s79 () Bool (= s1 s26))+[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 7))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 114+[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 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 7))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 116+[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 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 7))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[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 7))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[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 7))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 120+[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 s63)+Fast allSat, Looking for solution 121+[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 s62)+Fast allSat, Looking for solution 122+[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 s61)+Fast allSat, Looking for solution 123+[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 s60)+Fast allSat, Looking for solution 124+[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 s58)+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 s72)+[GOOD] (define-fun s80 () Bool (= s1 s28))+[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 8))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 126+[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 s60)+Fast allSat, Looking for solution 127+[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 s61)+Fast allSat, Looking for solution 128+[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 s62)+Fast allSat, Looking for solution 129+[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 s63)+Fast allSat, Looking for solution 130+[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 7))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 131+[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 s66)+Fast allSat, Looking for solution 132+[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 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 8))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[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 8))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[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 8))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[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 8))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[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 s72)+[GOOD] (define-fun s81 () Bool (= s1 s30))+[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 9))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 138+[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 s65)+Fast allSat, Looking for solution 139+[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 s66)+Fast allSat, Looking for solution 140+[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 s67)+Fast allSat, Looking for solution 141+[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 s68)+Fast allSat, Looking for solution 142+[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 s69)+Fast allSat, Looking for solution 143+[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 s70)+Fast allSat, Looking for solution 144+[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 s71)+Fast allSat, Looking for solution 145+[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 s62)+Fast allSat, Looking for solution 146+[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 s61)+Fast allSat, Looking for solution 147+[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 s60)+Fast allSat, Looking for solution 148+[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 s58)+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 s72)+[GOOD] (define-fun s82 () Bool (= s1 s32))+[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 10))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 150+[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 s60)+Fast allSat, Looking for solution 151+[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 s61)+Fast allSat, Looking for solution 152+[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 9))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 153+[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 s64)+Fast allSat, Looking for solution 154+[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 s65)+Fast allSat, Looking for solution 155+[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 s66)+Fast allSat, Looking for solution 156+[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 s67)+Fast allSat, Looking for solution 157+[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 s68)+Fast allSat, Looking for solution 158+[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 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 10))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[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 10))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[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 s72)+[GOOD] (define-fun s83 () Bool (= s1 s34))+[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 11))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 162+[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 s63)+Fast allSat, Looking for solution 163+[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 s64)+Fast allSat, Looking for solution 164+[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 s65)+Fast allSat, Looking for solution 165+[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 s66)+Fast allSat, Looking for solution 166+[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 s67)+Fast allSat, Looking for solution 167+[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 s68)+Fast allSat, Looking for solution 168+[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 s69)+Fast allSat, Looking for solution 169+[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 s70)+Fast allSat, Looking for solution 170+[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 s71)+Fast allSat, Looking for solution 171+[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 s60)+Fast allSat, Looking for solution 172+[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 s58)+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 s72)+[GOOD] (define-fun s84 () Bool (= s1 s36))+[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 12))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 174+[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 11))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 175+[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 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 12))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 177+[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 s64)+Fast allSat, Looking for solution 178+[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 s65)+Fast allSat, Looking for solution 179+[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 s66)+Fast allSat, Looking for solution 180+[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 s67)+Fast allSat, Looking for solution 181+[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 s68)+Fast allSat, Looking for solution 182+[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 s69)+Fast allSat, Looking for solution 183+[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 s70)+Fast allSat, Looking for solution 184+[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 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 s72)+[GOOD] (assert s44)+[GOOD] (define-fun s85 () Bool (= s1 s38))+[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 13))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 186+[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 s61)+Fast allSat, Looking for solution 187+[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 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 13))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 189+[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 s64)+Fast allSat, Looking for solution 190+[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 s65)+Fast allSat, Looking for solution 191+[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 s66)+Fast allSat, Looking for solution 192+[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 s67)+Fast allSat, Looking for solution 193+[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 s68)+Fast allSat, Looking for solution 194+[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 s69)+Fast allSat, Looking for solution 195+[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 s70)+Fast allSat, Looking for solution 196+[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 s71)+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] (assert s43)+[GOOD] (define-fun s86 () Bool (= s0 s40))+[GOOD] (assert s86)+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 11))+[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 11))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[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 10))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[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 9))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[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 8))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[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 7))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[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 6))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[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 5))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[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 4))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[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 3))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[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 2))+[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 1))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[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 15))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (define-fun s87 () Bool (distinct s1 s5))+[GOOD] (assert s87)+Fast allSat, Looking for solution 210+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s58)+[GOOD] (define-fun s88 () Bool (= s1 s5))+[GOOD] (assert s88)+Fast allSat, Looking for solution 210+[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 s60)+Fast allSat, Looking for solution 211+[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 s61)+Fast allSat, Looking for solution 212+[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 s62)+Fast allSat, Looking for solution 213+[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 s63)+Fast allSat, Looking for solution 214+[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 s64)+Fast allSat, Looking for solution 215+[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 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 15))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 217+[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 s67)+Fast allSat, Looking for solution 218+[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 s68)+Fast allSat, Looking for solution 219+[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 s69)+Fast allSat, Looking for solution 220+[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 s70)+Fast allSat, Looking for solution 221+[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 s71)+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 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 1))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s58)+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 12))+[GOOD] (push 1)+[GOOD] (assert s60)+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 11))+[GOOD] (push 1)+[GOOD] (assert s61)+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 10))+[GOOD] (push 1)+[GOOD] (assert s62)+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 9))+[GOOD] (push 1)+[GOOD] (assert s63)+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 8))+[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 7))+[GOOD] (push 1)+[GOOD] (assert s65)+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 6))+[GOOD] (push 1)+[GOOD] (assert s66)+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 5))+[GOOD] (push 1)+[GOOD] (assert s67)+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 4))+[GOOD] (push 1)+[GOOD] (assert s68)+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 3))+[GOOD] (push 1)+[GOOD] (assert s69)+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] (define-fun s89 () Bool (distinct s2 s5))+[GOOD] (assert s89)+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 s71)+[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 2))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s89)+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 13))+[GOOD] (push 1)+[GOOD] (assert s58)+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 12))+[GOOD] (push 1)+[GOOD] (assert s60)+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 11))+[GOOD] (push 1)+[GOOD] (assert s61)+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 10))+[GOOD] (push 1)+[GOOD] (assert s62)+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 9))+[GOOD] (push 1)+[GOOD] (assert s63)+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 8))+[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 7))+[GOOD] (push 1)+[GOOD] (assert s65)+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 6))+[GOOD] (push 1)+[GOOD] (assert s66)+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 5))+[GOOD] (push 1)+[GOOD] (assert s67)+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 4))+[GOOD] (push 1)+[GOOD] (assert s68)+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 3))+[GOOD] (push 1)+[GOOD] (assert s69)+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 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 3))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[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 12))+[GOOD] (push 1)+[GOOD] (assert s60)+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 11))+[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 10))+[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 9))+[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 8))+[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 7))+[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 6))+[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 5))+[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 4))+[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 15))+[GOOD] (push 1)+[GOOD] (assert s89)+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 1))+[GOOD] (push 1)+[GOOD] (assert s71)+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 s69)+[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 4))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s71)+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 2))+[GOOD] (push 1)+[GOOD] (assert s70)+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 5))+[GOOD] (push 1)+[GOOD] (assert s67)+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 6))+[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 7))+[GOOD] (push 1)+[GOOD] (assert s65)+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 8))+[GOOD] (push 1)+[GOOD] (assert s64)+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 9))+[GOOD] (push 1)+[GOOD] (assert s63)+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 10))+[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 11))+[GOOD] (push 1)+[GOOD] (assert s61)+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 12))+[GOOD] (push 1)+[GOOD] (assert s60)+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 13))+[GOOD] (push 1)+[GOOD] (assert s58)+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 s89)+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 s68)+[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 5))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s89)+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 13))+[GOOD] (push 1)+[GOOD] (assert s58)+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 12))+[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 5))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s61)+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 10))+[GOOD] (push 1)+[GOOD] (assert s62)+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 9))+[GOOD] (push 1)+[GOOD] (assert s63)+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 8))+[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 7))+[GOOD] (push 1)+[GOOD] (assert s65)+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 6))+[GOOD] (push 1)+[GOOD] (assert s66)+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 s69)+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 s70)+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 s71)+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 s67)+[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 6))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s71)+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 2))+[GOOD] (push 1)+[GOOD] (assert s70)+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 s69)+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 4))+[GOOD] (push 1)+[GOOD] (assert s68)+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 7))+[GOOD] (push 1)+[GOOD] (assert s65)+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 8))+[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 9))+[GOOD] (push 1)+[GOOD] (assert s63)+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 10))+[GOOD] (push 1)+[GOOD] (assert s62)+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 11))+[GOOD] (push 1)+[GOOD] (assert s61)+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 12))+[GOOD] (push 1)+[GOOD] (assert s60)+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 13))+[GOOD] (push 1)+[GOOD] (assert s58)+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 s89)+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 s66)+[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 7))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s89)+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 13))+[GOOD] (push 1)+[GOOD] (assert s58)+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 12))+[GOOD] (push 1)+[GOOD] (assert s60)+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 11))+[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 7))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s62)+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 9))+[GOOD] (push 1)+[GOOD] (assert s63)+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 8))+[GOOD] (push 1)+[GOOD] (assert s64)+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 s67)+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 s68)+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 s69)+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 s70)+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 s71)+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 s65)+[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 8))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s71)+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 2))+[GOOD] (push 1)+[GOOD] (assert s70)+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 3))+[GOOD] (push 1)+[GOOD] (assert s69)+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 s68)+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 5))+[GOOD] (push 1)+[GOOD] (assert s67)+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 6))+[GOOD] (push 1)+[GOOD] (assert s66)+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 15))+[GOOD] (push 1)+[GOOD] (assert s89)+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 13))+[GOOD] (push 1)+[GOOD] (assert s58)+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 12))+[GOOD] (push 1)+[GOOD] (assert s60)+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 s61)+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 10))+[GOOD] (push 1)+[GOOD] (assert s62)+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 9))+[GOOD] (push 1)+[GOOD] (assert s63)+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 s64)+[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 9))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s62)+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 11))+[GOOD] (push 1)+[GOOD] (assert s61)+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 12))+[GOOD] (push 1)+[GOOD] (assert s60)+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 13))+[GOOD] (push 1)+[GOOD] (assert s58)+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 15))+[GOOD] (push 1)+[GOOD] (assert s89)+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 s65)+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 s66)+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 s67)+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 s68)+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 s69)+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 s70)+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 s71)+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 s63)+[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 10))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s71)+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 2))+[GOOD] (push 1)+[GOOD] (assert s70)+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 3))+[GOOD] (push 1)+[GOOD] (assert s69)+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 4))+[GOOD] (push 1)+[GOOD] (assert s68)+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 s67)+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 6))+[GOOD] (push 1)+[GOOD] (assert s66)+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 7))+[GOOD] (push 1)+[GOOD] (assert s65)+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 8))+[GOOD] (push 1)+[GOOD] (assert s64)+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 11))+[GOOD] (push 1)+[GOOD] (assert s61)+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 12))+[GOOD] (push 1)+[GOOD] (assert s60)+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 13))+[GOOD] (push 1)+[GOOD] (assert s58)+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 s89)+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 s62)+[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 11))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s89)+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 13))+[GOOD] (push 1)+[GOOD] (assert s58)+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 12))+[GOOD] (push 1)+[GOOD] (assert s60)+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 s63)+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 s64)+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 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 11))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s66)+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 s67)+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 s68)+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 s69)+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 s70)+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 s71)+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 s61)+[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 12))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s71)+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 2))+[GOOD] (push 1)+[GOOD] (assert s70)+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 3))+[GOOD] (push 1)+[GOOD] (assert s69)+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 4))+[GOOD] (push 1)+[GOOD] (assert s68)+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 5))+[GOOD] (push 1)+[GOOD] (assert s67)+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 s66)+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 7))+[GOOD] (push 1)+[GOOD] (assert s65)+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 8))+[GOOD] (push 1)+[GOOD] (assert s64)+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 9))+[GOOD] (push 1)+[GOOD] (assert s63)+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 10))+[GOOD] (push 1)+[GOOD] (assert s62)+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 13))+[GOOD] (push 1)+[GOOD] (assert s58)+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 s89)+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 s89)+[GOOD] (assert s86)+[GOOD] (assert s85)+Fast allSat, Looking for solution 366+[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 s60)+Fast allSat, Looking for solution 367+[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 s61)+Fast allSat, Looking for solution 368+[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 s62)+Fast allSat, Looking for solution 369+[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 s63)+Fast allSat, Looking for solution 370+[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 s64)+Fast allSat, Looking for solution 371+[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 s65)+Fast allSat, Looking for solution 372+[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 s66)+Fast allSat, Looking for solution 373+[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 s67)+Fast allSat, Looking for solution 374+[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 s68)+Fast allSat, Looking for solution 375+[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 s69)+Fast allSat, Looking for solution 376+[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 s70)+Fast allSat, Looking for solution 377+[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 s71)+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 s45)+[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 11))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s46)+Fast allSat, Looking for solution 379+[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 s47)+Fast allSat, Looking for solution 380+[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 s48)+Fast allSat, Looking for solution 381+[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 s49)+Fast allSat, Looking for solution 382+[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 s50)+Fast allSat, Looking for solution 383+[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 s51)+Fast allSat, Looking for solution 384+[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 s52)+Fast allSat, Looking for solution 385+[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 s53)+Fast allSat, Looking for solution 386+[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 s54)+Fast allSat, Looking for solution 387+[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 s55)+Fast allSat, Looking for solution 388+[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 s57)+Fast allSat, Looking for solution 389+[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 s87)+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 12))+[GOOD] (push 1)+[GOOD] (assert s56)+Fast allSat, Looking for solution 391+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s60)+[GOOD] (assert s73)+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 11))+[GOOD] (push 1)+[GOOD] (assert s61)+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 10))+[GOOD] (push 1)+[GOOD] (assert s62)+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 9))+[GOOD] (push 1)+[GOOD] (assert s63)+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 8))+[GOOD] (push 1)+[GOOD] (assert s64)+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 s65)+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 6))+[GOOD] (push 1)+[GOOD] (assert s66)+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 5))+[GOOD] (push 1)+[GOOD] (assert s67)+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 4))+[GOOD] (push 1)+[GOOD] (assert s68)+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 3))+[GOOD] (push 1)+[GOOD] (assert s69)+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 2))+[GOOD] (push 1)+[GOOD] (assert s70)+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 s72)+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 s89)+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 s60)+[GOOD] (assert s88)+Fast allSat, Looking for solution 403+[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 s61)+Fast allSat, Looking for solution 404+[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 s62)+Fast allSat, Looking for solution 405+[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 s63)+Fast allSat, Looking for solution 406+[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 s64)+Fast allSat, Looking for solution 407+[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 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 15))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[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 15))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 410+[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 s68)+Fast allSat, Looking for solution 411+[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 s69)+Fast allSat, Looking for solution 412+[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 s70)+Fast allSat, Looking for solution 413+[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 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 15))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s72)+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 s60)+[GOOD] (assert s59)+Fast allSat, Looking for solution 415+[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 s61)+Fast allSat, Looking for solution 416+[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 s62)+Fast allSat, Looking for solution 417+[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 s63)+Fast allSat, Looking for solution 418+[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 s64)+Fast allSat, Looking for solution 419+[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 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 14))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[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 14))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 422+[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 s68)+Fast allSat, Looking for solution 423+[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 s69)+Fast allSat, Looking for solution 424+[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 s70)+Fast allSat, Looking for solution 425+[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 s71)+Fast allSat, Looking for solution 426+[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 15))+[GOOD] (push 1)+[GOOD] (assert s89)+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 s71)+[GOOD] (assert s74)+Fast allSat, Looking for solution 427+[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 s72)+Fast allSat, Looking for solution 428+[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 s89)+Fast allSat, Looking for solution 429+[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 s60)+Fast allSat, Looking for solution 430+[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 s61)+Fast allSat, Looking for solution 431+[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 s62)+Fast allSat, Looking for solution 432+[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 s63)+Fast allSat, Looking for solution 433+[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 s64)+Fast allSat, Looking for solution 434+[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 s65)+Fast allSat, Looking for solution 435+[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 s66)+Fast allSat, Looking for solution 436+[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 s67)+Fast allSat, Looking for solution 437+[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 s68)+Fast allSat, Looking for solution 438+[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 s69)+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 s70)+[GOOD] (assert s75)+Fast allSat, Looking for solution 439+[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 s60)+Fast allSat, Looking for solution 440+[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 s72)+Fast allSat, Looking for solution 441+[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 s89)+Fast allSat, Looking for solution 442+[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 s61)+Fast allSat, Looking for solution 443+[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 s62)+Fast allSat, Looking for solution 444+[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 s63)+Fast allSat, Looking for solution 445+[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 s64)+Fast allSat, Looking for solution 446+[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 s65)+Fast allSat, Looking for solution 447+[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 s66)+Fast allSat, Looking for solution 448+[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 s67)+Fast allSat, Looking for solution 449+[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 s68)+Fast allSat, Looking for solution 450+[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 s71)+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 s69)+[GOOD] (assert s76)+Fast allSat, Looking for solution 451+[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 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 4))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 453+[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 s72)+Fast allSat, Looking for solution 454+[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 s89)+Fast allSat, Looking for solution 455+[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 s60)+Fast allSat, Looking for solution 456+[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 s61)+Fast allSat, Looking for solution 457+[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 s62)+Fast allSat, Looking for solution 458+[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 s63)+Fast allSat, Looking for solution 459+[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 s64)+Fast allSat, Looking for solution 460+[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 s65)+Fast allSat, Looking for solution 461+[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 s66)+Fast allSat, Looking for solution 462+[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 s67)+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 s68)+[GOOD] (assert s77)+Fast allSat, Looking for solution 463+[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 s60)+Fast allSat, Looking for solution 464+[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 s72)+Fast allSat, Looking for solution 465+[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 s89)+Fast allSat, Looking for solution 466+[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 s61)+Fast allSat, Looking for solution 467+[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 s62)+Fast allSat, Looking for solution 468+[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 s63)+Fast allSat, Looking for solution 469+[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 s64)+Fast allSat, Looking for solution 470+[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 s65)+Fast allSat, Looking for solution 471+[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 s66)+Fast allSat, Looking for solution 472+[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 s69)+Fast allSat, Looking for solution 473+[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 s70)+Fast allSat, Looking for solution 474+[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 s71)+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 s67)+[GOOD] (assert s78)+Fast allSat, Looking for solution 475+[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 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 6))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 477+[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 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 6))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[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 6))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 480+[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 s89)+Fast allSat, Looking for solution 481+[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 s60)+Fast allSat, Looking for solution 482+[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 s61)+Fast allSat, Looking for solution 483+[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 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 6))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 485+[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 s64)+Fast allSat, Looking for solution 486+[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 s65)+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 s66)+[GOOD] (assert s79)+Fast allSat, Looking for solution 487+[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 s60)+Fast allSat, Looking for solution 488+[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 s72)+Fast allSat, Looking for solution 489+[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 s89)+Fast allSat, Looking for solution 490+[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 s61)+Fast allSat, Looking for solution 491+[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 s62)+Fast allSat, Looking for solution 492+[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 s63)+Fast allSat, Looking for solution 493+[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 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 7))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 495+[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 s68)+Fast allSat, Looking for solution 496+[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 s69)+Fast allSat, Looking for solution 497+[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 s70)+Fast allSat, Looking for solution 498+[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 s71)+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 s65)+[GOOD] (assert s80)+Fast allSat, Looking for solution 499+[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 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 8))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 501+[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 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 8))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[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 8))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 504+[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 s66)+Fast allSat, Looking for solution 505+[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 s63)+Fast allSat, Looking for solution 506+[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 s62)+Fast allSat, Looking for solution 507+[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 s61)+Fast allSat, Looking for solution 508+[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 s60)+Fast allSat, Looking for solution 509+[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 s72)+Fast allSat, Looking for solution 510+[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 s89)+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 s64)+[GOOD] (assert s81)+Fast allSat, Looking for solution 511+[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 s89)+Fast allSat, Looking for solution 512+[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 s72)+Fast allSat, Looking for solution 513+[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 s60)+Fast allSat, Looking for solution 514+[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 s61)+Fast allSat, Looking for solution 515+[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 s62)+Fast allSat, Looking for solution 516+[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 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 9))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 518+[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 s67)+Fast allSat, Looking for solution 519+[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 s68)+Fast allSat, Looking for solution 520+[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 s69)+Fast allSat, Looking for solution 521+[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 s70)+Fast allSat, Looking for solution 522+[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 s71)+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 s63)+[GOOD] (assert s82)+Fast allSat, Looking for solution 523+[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 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 10))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 525+[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 s69)+Fast allSat, Looking for solution 526+[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 s68)+Fast allSat, Looking for solution 527+[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 s67)+Fast allSat, Looking for solution 528+[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 s66)+Fast allSat, Looking for solution 529+[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 s65)+Fast allSat, Looking for solution 530+[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 s64)+Fast allSat, Looking for solution 531+[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 s61)+Fast allSat, Looking for solution 532+[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 s60)+Fast allSat, Looking for solution 533+[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 s72)+Fast allSat, Looking for solution 534+[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 s89)+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 s62)+[GOOD] (assert s83)+Fast allSat, Looking for solution 535+[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 s89)+Fast allSat, Looking for solution 536+[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 s72)+Fast allSat, Looking for solution 537+[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 s60)+Fast allSat, Looking for solution 538+[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 s63)+Fast allSat, Looking for solution 539+[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 s64)+Fast allSat, Looking for solution 540+[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 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 11))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 542+[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 s67)+Fast allSat, Looking for solution 543+[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 s68)+Fast allSat, Looking for solution 544+[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 s69)+Fast allSat, Looking for solution 545+[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 s70)+Fast allSat, Looking for solution 546+[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 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 s72)+[GOOD] (assert s90)+[GOOD] (assert s84)+Fast allSat, Looking for solution 547+[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 s71)+Fast allSat, Looking for solution 548+[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 s70)+Fast allSat, Looking for solution 549+[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 s69)+Fast allSat, Looking for solution 550+[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 s68)+Fast allSat, Looking for solution 551+[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 s67)+Fast allSat, Looking for solution 552+[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 s66)+Fast allSat, Looking for solution 553+[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 s65)+Fast allSat, Looking for solution 554+[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 s64)+Fast allSat, Looking for solution 555+[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 s63)+Fast allSat, Looking for solution 556+[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 s62)+Fast allSat, Looking for solution 557+[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 s61)+Fast allSat, Looking for solution 558+[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 s89)+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 s46)+[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 10))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s47)+Fast allSat, Looking for solution 560+[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 s48)+Fast allSat, Looking for solution 561+[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 s49)+Fast allSat, Looking for solution 562+[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 s50)+Fast allSat, Looking for solution 563+[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 s51)+Fast allSat, Looking for solution 564+[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 s52)+Fast allSat, Looking for solution 565+[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 s53)+Fast allSat, Looking for solution 566+[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 s54)+Fast allSat, Looking for solution 567+[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 s55)+Fast allSat, Looking for solution 568+[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 s56)+Fast allSat, Looking for solution 569+[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 s43)+Fast allSat, Looking for solution 570+[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 s57)+Fast allSat, Looking for solution 571+[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 s87)+Fast allSat, Looking for solution 572+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s61)+[GOOD] (assert s88)+Fast allSat, Looking for solution 572+[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 s62)+Fast allSat, Looking for solution 573+[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 s63)+Fast allSat, Looking for solution 574+[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 s64)+Fast allSat, Looking for solution 575+[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 s65)+Fast allSat, Looking for solution 576+[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 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 15))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 578+[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 s68)+Fast allSat, Looking for solution 579+[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 s69)+Fast allSat, Looking for solution 580+[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 s70)+Fast allSat, Looking for solution 581+[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 s71)+Fast allSat, Looking for solution 582+[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 s58)+Fast allSat, Looking for solution 583+[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 s72)+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 s89)+[GOOD] (assert s59)+Fast allSat, Looking for solution 584+[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 s58)+Fast allSat, Looking for solution 585+[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 s61)+Fast allSat, Looking for solution 586+[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 s62)+Fast allSat, Looking for solution 587+[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 s63)+Fast allSat, Looking for solution 588+[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 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 14))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 590+[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 s66)+Fast allSat, Looking for solution 591+[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 s67)+Fast allSat, Looking for solution 592+[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 s68)+Fast allSat, Looking for solution 593+[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 s69)+Fast allSat, Looking for solution 594+[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 s70)+Fast allSat, Looking for solution 595+[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 s71)+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 s89)+[GOOD] (assert s85)+Fast allSat, Looking for solution 596+[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 s61)+Fast allSat, Looking for solution 597+[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 s62)+Fast allSat, Looking for solution 598+[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 s63)+Fast allSat, Looking for solution 599+[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 s64)+Fast allSat, Looking for solution 600+[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 s65)+Fast allSat, Looking for solution 601+[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 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 13))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 603+[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 s68)+Fast allSat, Looking for solution 604+[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 s69)+Fast allSat, Looking for solution 605+[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 s70)+Fast allSat, Looking for solution 606+[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 s71)+Fast allSat, Looking for solution 607+[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 14))+[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 s89)+[GOOD] (assert s73)+Fast allSat, Looking for solution 608+[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 s58)+Fast allSat, Looking for solution 609+[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 s72)+Fast allSat, Looking for solution 610+[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 s61)+Fast allSat, Looking for solution 611+[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 s62)+Fast allSat, Looking for solution 612+[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 s63)+Fast allSat, Looking for solution 613+[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 s64)+Fast allSat, Looking for solution 614+[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 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 1))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 616+[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 s67)+Fast allSat, Looking for solution 617+[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 s68)+Fast allSat, Looking for solution 618+[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 s69)+Fast allSat, Looking for solution 619+[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 s70)+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 s89)+[GOOD] (assert s74)+Fast allSat, Looking for solution 620+[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 s61)+Fast allSat, Looking for solution 621+[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 s62)+Fast allSat, Looking for solution 622+[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 s63)+Fast allSat, Looking for solution 623+[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 s64)+Fast allSat, Looking for solution 624+[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 s65)+Fast allSat, Looking for solution 625+[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 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 2))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 627+[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 s68)+Fast allSat, Looking for solution 628+[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 s69)+Fast allSat, Looking for solution 629+[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 s71)+Fast allSat, Looking for solution 630+[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 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 2))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[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 s89)+[GOOD] (assert s75)+Fast allSat, Looking for solution 632+[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 s72)+Fast allSat, Looking for solution 633+[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 s58)+Fast allSat, Looking for solution 634+[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 s61)+Fast allSat, Looking for solution 635+[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 s62)+Fast allSat, Looking for solution 636+[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 s63)+Fast allSat, Looking for solution 637+[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 s64)+Fast allSat, Looking for solution 638+[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 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 3))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 640+[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 s67)+Fast allSat, Looking for solution 641+[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 s68)+Fast allSat, Looking for solution 642+[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 s70)+Fast allSat, Looking for solution 643+[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 s71)+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 s89)+[GOOD] (assert s76)+Fast allSat, Looking for solution 644+[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 s69)+Fast allSat, Looking for solution 645+[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 s70)+Fast allSat, Looking for solution 646+[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 s71)+Fast allSat, Looking for solution 647+[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 s67)+Fast allSat, Looking for solution 648+[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 s66)+Fast allSat, Looking for solution 649+[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 s65)+Fast allSat, Looking for solution 650+[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 s64)+Fast allSat, Looking for solution 651+[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 s63)+Fast allSat, Looking for solution 652+[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 s62)+Fast allSat, Looking for solution 653+[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 s61)+Fast allSat, Looking for solution 654+[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 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 4))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[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 s89)+[GOOD] (assert s77)+Fast allSat, Looking for solution 656+[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 s72)+Fast allSat, Looking for solution 657+[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 s58)+Fast allSat, Looking for solution 658+[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 s61)+Fast allSat, Looking for solution 659+[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 s62)+Fast allSat, Looking for solution 660+[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 s63)+Fast allSat, Looking for solution 661+[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 s64)+Fast allSat, Looking for solution 662+[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 s65)+Fast allSat, Looking for solution 663+[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 s66)+Fast allSat, Looking for solution 664+[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 s68)+Fast allSat, Looking for solution 665+[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 s69)+Fast allSat, Looking for solution 666+[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 s70)+Fast allSat, Looking for solution 667+[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 s71)+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 s89)+[GOOD] (assert s78)+Fast allSat, Looking for solution 668+[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 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 6))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[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 6))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 671+[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 s70)+Fast allSat, Looking for solution 672+[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 s71)+Fast allSat, Looking for solution 673+[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 s65)+Fast allSat, Looking for solution 674+[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 s64)+Fast allSat, Looking for solution 675+[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 s63)+Fast allSat, Looking for solution 676+[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 s62)+Fast allSat, Looking for solution 677+[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 s61)+Fast allSat, Looking for solution 678+[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 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 6))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[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 s89)+[GOOD] (assert s79)+Fast allSat, Looking for solution 680+[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 s72)+Fast allSat, Looking for solution 681+[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 s58)+Fast allSat, Looking for solution 682+[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 s61)+Fast allSat, Looking for solution 683+[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 s62)+Fast allSat, Looking for solution 684+[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 s63)+Fast allSat, Looking for solution 685+[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 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 7))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 687+[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 s67)+Fast allSat, Looking for solution 688+[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 s68)+Fast allSat, Looking for solution 689+[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 s69)+Fast allSat, Looking for solution 690+[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 s70)+Fast allSat, Looking for solution 691+[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 s71)+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 s89)+[GOOD] (assert s80)+Fast allSat, Looking for solution 692+[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 s65)+Fast allSat, Looking for solution 693+[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 s66)+Fast allSat, Looking for solution 694+[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 s67)+Fast allSat, Looking for solution 695+[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 s68)+Fast allSat, Looking for solution 696+[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 s69)+Fast allSat, Looking for solution 697+[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 s70)+Fast allSat, Looking for solution 698+[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 s71)+Fast allSat, Looking for solution 699+[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 s63)+Fast allSat, Looking for solution 700+[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 s62)+Fast allSat, Looking for solution 701+[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 s61)+Fast allSat, Looking for solution 702+[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 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 8))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[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 s89)+[GOOD] (assert s81)+Fast allSat, Looking for solution 704+[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 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 9))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[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 9))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 707+[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 s62)+Fast allSat, Looking for solution 708+[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 s64)+Fast allSat, Looking for solution 709+[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 s65)+Fast allSat, Looking for solution 710+[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 s66)+Fast allSat, Looking for solution 711+[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 s67)+Fast allSat, Looking for solution 712+[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 s68)+Fast allSat, Looking for solution 713+[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 s69)+Fast allSat, Looking for solution 714+[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 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 9))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[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 s89)+[GOOD] (assert s82)+Fast allSat, Looking for solution 716+[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 s63)+Fast allSat, Looking for solution 717+[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 s64)+Fast allSat, Looking for solution 718+[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 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 10))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 720+[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 s67)+Fast allSat, Looking for solution 721+[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 s68)+Fast allSat, Looking for solution 722+[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 s69)+Fast allSat, Looking for solution 723+[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 s70)+Fast allSat, Looking for solution 724+[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 s71)+Fast allSat, Looking for solution 725+[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 s61)+Fast allSat, Looking for solution 726+[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 s58)+Fast allSat, Looking for solution 727+[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 s72)+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 s58)+[GOOD] (assert s91)+[GOOD] (assert s83)+Fast allSat, Looking for solution 728+[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 s72)+Fast allSat, Looking for solution 729+[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 s89)+Fast allSat, Looking for solution 730+[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 s62)+Fast allSat, Looking for solution 731+[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 s63)+Fast allSat, Looking for solution 732+[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 s64)+Fast allSat, Looking for solution 733+[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 s65)+Fast allSat, Looking for solution 734+[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 s66)+Fast allSat, Looking for solution 735+[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 s67)+Fast allSat, Looking for solution 736+[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 s68)+Fast allSat, Looking for solution 737+[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 s69)+Fast allSat, Looking for solution 738+[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 s70)+Fast allSat, Looking for solution 739+[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 s71)+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 s47)+[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 9))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s48)+Fast allSat, Looking for solution 741+[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 s49)+Fast allSat, Looking for solution 742+[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 s50)+Fast allSat, Looking for solution 743+[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 s51)+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 4))+[GOOD] (push 1)+[GOOD] (assert s52)+Fast allSat, Looking for solution 745+[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 s53)+Fast allSat, Looking for solution 746+[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 s54)+Fast allSat, Looking for solution 747+[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 s55)+Fast allSat, Looking for solution 748+[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 s45)+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 10))+[GOOD] (push 1)+[GOOD] (assert s43)+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 10))+[GOOD] (push 1)+[GOOD] (assert s57)+Fast allSat, Looking for solution 751+[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 s87)+Fast allSat, Looking for solution 752+[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 s56)+Fast allSat, Looking for solution 753+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s62)+[GOOD] (assert s73)+Fast allSat, Looking for solution 753+[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 s63)+Fast allSat, Looking for solution 754+[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 s64)+Fast allSat, Looking for solution 755+[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 s65)+Fast allSat, Looking for solution 756+[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 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 1))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 758+[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 s68)+Fast allSat, Looking for solution 759+[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 s69)+Fast allSat, Looking for solution 760+[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 s70)+Fast allSat, Looking for solution 761+[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 s60)+Fast allSat, Looking for solution 762+[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 s58)+Fast allSat, Looking for solution 763+[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 s72)+Fast allSat, Looking for solution 764+[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 s89)+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 s62)+[GOOD] (assert s88)+Fast allSat, Looking for solution 765+[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 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 15))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[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 15))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[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 15))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 769+[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 s64)+Fast allSat, Looking for solution 770+[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 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 15))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 772+[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 s67)+Fast allSat, Looking for solution 773+[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 s68)+Fast allSat, Looking for solution 774+[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 s69)+Fast allSat, Looking for solution 775+[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 s70)+Fast allSat, Looking for solution 776+[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 s71)+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 s62)+[GOOD] (assert s59)+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 1))+[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 14))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s70)+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 s69)+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 s68)+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 s67)+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 s66)+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 s65)+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 s64)+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 s63)+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 15))+[GOOD] (push 1)+[GOOD] (assert s89)+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 13))+[GOOD] (push 1)+[GOOD] (assert s58)+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 12))+[GOOD] (push 1)+[GOOD] (assert s60)+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 s62)+[GOOD] (assert s85)+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 12))+[GOOD] (push 1)+[GOOD] (assert s60)+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 14))+[GOOD] (push 1)+[GOOD] (assert s72)+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 15))+[GOOD] (push 1)+[GOOD] (assert s89)+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 9))+[GOOD] (push 1)+[GOOD] (assert s63)+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 8))+[GOOD] (push 1)+[GOOD] (assert s64)+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 7))+[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 13))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s66)+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 5))+[GOOD] (push 1)+[GOOD] (assert s67)+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 4))+[GOOD] (push 1)+[GOOD] (assert s68)+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 3))+[GOOD] (push 1)+[GOOD] (assert s69)+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 2))+[GOOD] (push 1)+[GOOD] (assert s70)+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 1))+[GOOD] (push 1)+[GOOD] (assert s71)+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 s62)+[GOOD] (assert s84)+Fast allSat, Looking for solution 801+[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 s71)+Fast allSat, Looking for solution 802+[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 s70)+Fast allSat, Looking for solution 803+[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 s69)+Fast allSat, Looking for solution 804+[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 s68)+Fast allSat, Looking for solution 805+[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 s67)+Fast allSat, Looking for solution 806+[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 s66)+Fast allSat, Looking for solution 807+[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 s65)+Fast allSat, Looking for solution 808+[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 s64)+Fast allSat, Looking for solution 809+[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 s63)+Fast allSat, Looking for solution 810+[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 13))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 811+[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 s72)+Fast allSat, Looking for solution 812+[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 s89)+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 s71)+[GOOD] (assert s74)+Fast allSat, Looking for solution 813+[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 s89)+Fast allSat, Looking for solution 814+[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 s72)+Fast allSat, Looking for solution 815+[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 s58)+Fast allSat, Looking for solution 816+[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 s60)+Fast allSat, Looking for solution 817+[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 s62)+Fast allSat, Looking for solution 818+[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 s63)+Fast allSat, Looking for solution 819+[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 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 2))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 821+[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 s66)+Fast allSat, Looking for solution 822+[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 s67)+Fast allSat, Looking for solution 823+[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 s68)+Fast allSat, Looking for solution 824+[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 s69)+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 s70)+[GOOD] (assert s75)+Fast allSat, Looking for solution 825+[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 s68)+Fast allSat, Looking for solution 826+[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 s67)+Fast allSat, Looking for solution 827+[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 s66)+Fast allSat, Looking for solution 828+[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 s65)+Fast allSat, Looking for solution 829+[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 s64)+Fast allSat, Looking for solution 830+[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 s63)+Fast allSat, Looking for solution 831+[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 s62)+Fast allSat, Looking for solution 832+[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 s60)+Fast allSat, Looking for solution 833+[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 s58)+Fast allSat, Looking for solution 834+[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 s72)+Fast allSat, Looking for solution 835+[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 s89)+Fast allSat, Looking for solution 836+[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 s71)+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 s76)+Fast allSat, Looking for solution 837+[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 s71)+Fast allSat, Looking for solution 838+[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 s70)+Fast allSat, Looking for solution 839+[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 s60)+Fast allSat, Looking for solution 840+[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 s58)+Fast allSat, Looking for solution 841+[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 s72)+Fast allSat, Looking for solution 842+[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 s89)+Fast allSat, Looking for solution 843+[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 s62)+Fast allSat, Looking for solution 844+[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 s63)+Fast allSat, Looking for solution 845+[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 s64)+Fast allSat, Looking for solution 846+[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 s65)+Fast allSat, Looking for solution 847+[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 s66)+Fast allSat, Looking for solution 848+[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 s67)+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 s68)+[GOOD] (assert s77)+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 10))+[GOOD] (push 1)+[GOOD] (assert s62)+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 9))+[GOOD] (push 1)+[GOOD] (assert s63)+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 8))+[GOOD] (push 1)+[GOOD] (assert s64)+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 7))+[GOOD] (push 1)+[GOOD] (assert s65)+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 6))+[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 5))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s60)+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 13))+[GOOD] (push 1)+[GOOD] (assert s58)+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 14))+[GOOD] (push 1)+[GOOD] (assert s72)+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 15))+[GOOD] (push 1)+[GOOD] (assert s89)+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 3))+[GOOD] (push 1)+[GOOD] (assert s69)+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 2))+[GOOD] (push 1)+[GOOD] (assert s70)+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 1))+[GOOD] (push 1)+[GOOD] (assert s71)+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 s67)+[GOOD] (assert s78)+Fast allSat, Looking for solution 861+[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 s71)+Fast allSat, Looking for solution 862+[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 s70)+Fast allSat, Looking for solution 863+[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 s69)+Fast allSat, Looking for solution 864+[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 s68)+Fast allSat, Looking for solution 865+[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 s60)+Fast allSat, Looking for solution 866+[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 s58)+Fast allSat, Looking for solution 867+[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 s72)+Fast allSat, Looking for solution 868+[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 s89)+Fast allSat, Looking for solution 869+[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 s62)+Fast allSat, Looking for solution 870+[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 s63)+Fast allSat, Looking for solution 871+[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 s64)+Fast allSat, Looking for solution 872+[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 s65)+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 s66)+[GOOD] (assert s79)+Fast allSat, Looking for solution 873+[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 s62)+Fast allSat, Looking for solution 874+[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 s63)+Fast allSat, Looking for solution 875+[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 s64)+Fast allSat, Looking for solution 876+[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 s60)+Fast allSat, Looking for solution 877+[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 s58)+Fast allSat, Looking for solution 878+[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 s72)+Fast allSat, Looking for solution 879+[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 s89)+Fast allSat, Looking for solution 880+[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 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 7))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 882+[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 s69)+Fast allSat, Looking for solution 883+[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 s70)+Fast allSat, Looking for solution 884+[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 s71)+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 s65)+[GOOD] (assert s80)+Fast allSat, Looking for solution 885+[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 s71)+Fast allSat, Looking for solution 886+[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 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 8))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 888+[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 s68)+Fast allSat, Looking for solution 889+[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 s67)+Fast allSat, Looking for solution 890+[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 s66)+Fast allSat, Looking for solution 891+[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 s60)+Fast allSat, Looking for solution 892+[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 s58)+Fast allSat, Looking for solution 893+[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 s72)+Fast allSat, Looking for solution 894+[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 s89)+Fast allSat, Looking for solution 895+[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 s62)+Fast allSat, Looking for solution 896+[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 s63)+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 s64)+[GOOD] (assert s81)+Fast allSat, Looking for solution 897+[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 s62)+Fast allSat, Looking for solution 898+[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 s60)+Fast allSat, Looking for solution 899+[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 s58)+Fast allSat, Looking for solution 900+[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 s72)+Fast allSat, Looking for solution 901+[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 s89)+Fast allSat, Looking for solution 902+[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 s65)+Fast allSat, Looking for solution 903+[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 s66)+Fast allSat, Looking for solution 904+[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 s67)+Fast allSat, Looking for solution 905+[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 s68)+Fast allSat, Looking for solution 906+[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 s69)+Fast allSat, Looking for solution 907+[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 s70)+Fast allSat, Looking for solution 908+[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 s71)+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 s60)+[GOOD] (assert s92)+[GOOD] (assert s82)+Fast allSat, Looking for solution 909+[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 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 10))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 911+[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 s69)+Fast allSat, Looking for solution 912+[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 s68)+Fast allSat, Looking for solution 913+[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 s67)+Fast allSat, Looking for solution 914+[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 s66)+Fast allSat, Looking for solution 915+[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 s65)+Fast allSat, Looking for solution 916+[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 s64)+Fast allSat, Looking for solution 917+[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 s63)+Fast allSat, Looking for solution 918+[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 s58)+Fast allSat, Looking for solution 919+[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 s72)+Fast allSat, Looking for solution 920+[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 s89)+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 s48)+[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 8))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s49)+Fast allSat, Looking for solution 922+[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 s50)+Fast allSat, Looking for solution 923+[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 s51)+Fast allSat, Looking for solution 924+[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 s52)+Fast allSat, Looking for solution 925+[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 s53)+Fast allSat, Looking for solution 926+[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 s54)+Fast allSat, Looking for solution 927+[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 s55)+Fast allSat, Looking for solution 928+[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 s56)+Fast allSat, Looking for solution 929+[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 s46)+Fast allSat, Looking for solution 930+[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 s45)+Fast allSat, Looking for solution 931+[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 s43)+Fast allSat, Looking for solution 932+[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 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 14))+[GOOD] (push 1)+[GOOD] (assert s87)+Fast allSat, Looking for solution 934+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s88)+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 13))+[GOOD] (push 1)+[GOOD] (assert s58)+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 12))+[GOOD] (push 1)+[GOOD] (assert s60)+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 11))+[GOOD] (push 1)+[GOOD] (assert s61)+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 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 15))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[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 15))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[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 15))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[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 15))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s67)+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 s68)+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 s69)+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 s70)+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 s71)+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 s89)+[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 14))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 947+[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 s64)+Fast allSat, Looking for solution 948+[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 s65)+Fast allSat, Looking for solution 949+[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 s66)+Fast allSat, Looking for solution 950+[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 s67)+Fast allSat, Looking for solution 951+[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 s68)+Fast allSat, Looking for solution 952+[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 s69)+Fast allSat, Looking for solution 953+[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 s70)+Fast allSat, Looking for solution 954+[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 s71)+Fast allSat, Looking for solution 955+[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 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 14))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[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 14))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[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 s89)+[GOOD] (assert s85)+Fast allSat, Looking for solution 958+[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 s60)+Fast allSat, Looking for solution 959+[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 s61)+Fast allSat, Looking for solution 960+[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 s63)+Fast allSat, Looking for solution 961+[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 s64)+Fast allSat, Looking for solution 962+[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 s65)+Fast allSat, Looking for solution 963+[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 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 13))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 965+[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 s68)+Fast allSat, Looking for solution 966+[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 s69)+Fast allSat, Looking for solution 967+[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 s70)+Fast allSat, Looking for solution 968+[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 s71)+Fast allSat, Looking for solution 969+[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 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 s89)+[GOOD] (assert s84)+Fast allSat, Looking for solution 970+[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 s58)+Fast allSat, Looking for solution 971+[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 s72)+Fast allSat, Looking for solution 972+[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 s61)+Fast allSat, Looking for solution 973+[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 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 12))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[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 12))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[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 12))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[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 12))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 978+[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 s68)+Fast allSat, Looking for solution 979+[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 s69)+Fast allSat, Looking for solution 980+[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 s70)+Fast allSat, Looking for solution 981+[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 s71)+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 s89)+[GOOD] (assert s83)+Fast allSat, Looking for solution 982+[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 s63)+Fast allSat, Looking for solution 983+[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 s64)+Fast allSat, Looking for solution 984+[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 s65)+Fast allSat, Looking for solution 985+[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 s66)+Fast allSat, Looking for solution 986+[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 s67)+Fast allSat, Looking for solution 987+[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 s68)+Fast allSat, Looking for solution 988+[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 s69)+Fast allSat, Looking for solution 989+[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 s70)+Fast allSat, Looking for solution 990+[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 s71)+Fast allSat, Looking for solution 991+[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 12))+[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 11))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[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 11))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[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 s89)+[GOOD] (assert s73)+Fast allSat, Looking for solution 994+[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 s72)+Fast allSat, Looking for solution 995+[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 s58)+Fast allSat, Looking for solution 996+[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 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 1))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 998+[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 s63)+Fast allSat, Looking for solution 999+[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 s64)+Fast allSat, Looking for solution 1000+[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 s65)+Fast allSat, Looking for solution 1001+[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 s66)+Fast allSat, Looking for solution 1002+[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 s67)+Fast allSat, Looking for solution 1003+[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 s68)+Fast allSat, Looking for solution 1004+[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 s69)+Fast allSat, Looking for solution 1005+[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 s70)+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 s89)+[GOOD] (assert s74)+Fast allSat, Looking for solution 1006+[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 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 2))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 1008+[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 s65)+Fast allSat, Looking for solution 1009+[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 s66)+Fast allSat, Looking for solution 1010+[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 s67)+Fast allSat, Looking for solution 1011+[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 s68)+Fast allSat, Looking for solution 1012+[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 s69)+Fast allSat, Looking for solution 1013+[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 s71)+Fast allSat, Looking for solution 1014+[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 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 2))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[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 2))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[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 2))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[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 s89)+[GOOD] (assert s75)+Fast allSat, Looking for solution 1018+[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 s72)+Fast allSat, Looking for solution 1019+[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 s58)+Fast allSat, Looking for solution 1020+[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 s60)+Fast allSat, Looking for solution 1021+[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 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 3))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 1023+[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 s64)+Fast allSat, Looking for solution 1024+[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 s65)+Fast allSat, Looking for solution 1025+[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 s66)+Fast allSat, Looking for solution 1026+[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 s67)+Fast allSat, Looking for solution 1027+[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 s68)+Fast allSat, Looking for solution 1028+[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 s70)+Fast allSat, Looking for solution 1029+[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 s71)+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 s89)+[GOOD] (assert s76)+Fast allSat, Looking for solution 1030+[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 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 4))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[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 4))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[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 4))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1034+[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 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 4))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1036+[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 s64)+Fast allSat, Looking for solution 1037+[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 s63)+Fast allSat, Looking for solution 1038+[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 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 4))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[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 4))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[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 4))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[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 s89)+[GOOD] (assert s77)+Fast allSat, Looking for solution 1042+[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 s72)+Fast allSat, Looking for solution 1043+[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 s58)+Fast allSat, Looking for solution 1044+[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 s60)+Fast allSat, Looking for solution 1045+[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 s61)+Fast allSat, Looking for solution 1046+[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 s63)+Fast allSat, Looking for solution 1047+[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 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 5))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1049+[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 s66)+Fast allSat, Looking for solution 1050+[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 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 5))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[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 5))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[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 5))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[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 s89)+[GOOD] (assert s78)+Fast allSat, Looking for solution 1054+[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 s67)+Fast allSat, Looking for solution 1055+[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 s68)+Fast allSat, Looking for solution 1056+[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 s69)+Fast allSat, Looking for solution 1057+[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 s70)+Fast allSat, Looking for solution 1058+[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 s71)+Fast allSat, Looking for solution 1059+[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 s65)+Fast allSat, Looking for solution 1060+[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 s64)+Fast allSat, Looking for solution 1061+[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 s63)+Fast allSat, Looking for solution 1062+[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 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 6))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[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 6))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[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 6))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[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 s89)+[GOOD] (assert s79)+Fast allSat, Looking for solution 1066+[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 s72)+Fast allSat, Looking for solution 1067+[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 s58)+Fast allSat, Looking for solution 1068+[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 s60)+Fast allSat, Looking for solution 1069+[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 s61)+Fast allSat, Looking for solution 1070+[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 s63)+Fast allSat, Looking for solution 1071+[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 s64)+Fast allSat, Looking for solution 1072+[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 s66)+Fast allSat, Looking for solution 1073+[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 s67)+Fast allSat, Looking for solution 1074+[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 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 7))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[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 7))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1077+[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 s71)+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 s89)+[GOOD] (assert s80)+Fast allSat, Looking for solution 1078+[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 s65)+Fast allSat, Looking for solution 1079+[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 s66)+Fast allSat, Looking for solution 1080+[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 s67)+Fast allSat, Looking for solution 1081+[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 s68)+Fast allSat, Looking for solution 1082+[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 s69)+Fast allSat, Looking for solution 1083+[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 s70)+Fast allSat, Looking for solution 1084+[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 s71)+Fast allSat, Looking for solution 1085+[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 s63)+Fast allSat, Looking for solution 1086+[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 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 8))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[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 8))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[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 8))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[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 s61)+[GOOD] (assert s93)+[GOOD] (assert s81)+Fast allSat, Looking for solution 1090+[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 s72)+Fast allSat, Looking for solution 1091+[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 s58)+Fast allSat, Looking for solution 1092+[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 s60)+Fast allSat, Looking for solution 1093+[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 s89)+Fast allSat, Looking for solution 1094+[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 s64)+Fast allSat, Looking for solution 1095+[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 s65)+Fast allSat, Looking for solution 1096+[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 s66)+Fast allSat, Looking for solution 1097+[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 s67)+Fast allSat, Looking for solution 1098+[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 s68)+Fast allSat, Looking for solution 1099+[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 s69)+Fast allSat, Looking for solution 1100+[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 s70)+Fast allSat, Looking for solution 1101+[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 s71)+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 s49)+[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 7))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s50)+Fast allSat, Looking for solution 1103+[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 s51)+Fast allSat, Looking for solution 1104+[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 s52)+Fast allSat, Looking for solution 1105+[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 s53)+Fast allSat, Looking for solution 1106+[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 s54)+Fast allSat, Looking for solution 1107+[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 s55)+Fast allSat, Looking for solution 1108+[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 s47)+Fast allSat, Looking for solution 1109+[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 s46)+Fast allSat, Looking for solution 1110+[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 s45)+Fast allSat, Looking for solution 1111+[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 s43)+Fast allSat, Looking for solution 1112+[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 s57)+Fast allSat, Looking for solution 1113+[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 s87)+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 8))+[GOOD] (push 1)+[GOOD] (assert s56)+Fast allSat, Looking for solution 1115+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s64)+[GOOD] (assert s73)+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 7))+[GOOD] (push 1)+[GOOD] (assert s65)+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 6))+[GOOD] (push 1)+[GOOD] (assert s66)+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 s67)+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 4))+[GOOD] (push 1)+[GOOD] (assert s68)+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 3))+[GOOD] (push 1)+[GOOD] (assert s69)+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 2))+[GOOD] (push 1)+[GOOD] (assert s70)+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 s62)+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 s61)+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 s60)+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 s58)+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 s72)+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 s89)+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 s64)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1127+[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 s62)+Fast allSat, Looking for solution 1128+[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 s61)+Fast allSat, Looking for solution 1129+[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 s60)+Fast allSat, Looking for solution 1130+[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 s58)+Fast allSat, Looking for solution 1131+[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 s72)+Fast allSat, Looking for solution 1132+[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 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 15))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1134+[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 s67)+Fast allSat, Looking for solution 1135+[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 s68)+Fast allSat, Looking for solution 1136+[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 s69)+Fast allSat, Looking for solution 1137+[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 s70)+Fast allSat, Looking for solution 1138+[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 s71)+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 s64)+[GOOD] (assert s59)+Fast allSat, Looking for solution 1139+[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 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 14))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1141+[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 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 14))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1143+[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 s67)+Fast allSat, Looking for solution 1144+[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 s66)+Fast allSat, Looking for solution 1145+[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 s65)+Fast allSat, Looking for solution 1146+[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 s89)+Fast allSat, Looking for solution 1147+[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 s58)+Fast allSat, Looking for solution 1148+[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 s60)+Fast allSat, Looking for solution 1149+[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 s61)+Fast allSat, Looking for solution 1150+[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 s62)+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 s64)+[GOOD] (assert s85)+Fast allSat, Looking for solution 1151+[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 s60)+Fast allSat, Looking for solution 1152+[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 s61)+Fast allSat, Looking for solution 1153+[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 s62)+Fast allSat, Looking for solution 1154+[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 s72)+Fast allSat, Looking for solution 1155+[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 s89)+Fast allSat, Looking for solution 1156+[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 s65)+Fast allSat, Looking for solution 1157+[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 s66)+Fast allSat, Looking for solution 1158+[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 s67)+Fast allSat, Looking for solution 1159+[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 s68)+Fast allSat, Looking for solution 1160+[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 s69)+Fast allSat, Looking for solution 1161+[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 s70)+Fast allSat, Looking for solution 1162+[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 s71)+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 s64)+[GOOD] (assert s84)+Fast allSat, Looking for solution 1163+[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 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 12))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1165+[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 s69)+Fast allSat, Looking for solution 1166+[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 s68)+Fast allSat, Looking for solution 1167+[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 s67)+Fast allSat, Looking for solution 1168+[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 s66)+Fast allSat, Looking for solution 1169+[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 s65)+Fast allSat, Looking for solution 1170+[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 s58)+Fast allSat, Looking for solution 1171+[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 s72)+Fast allSat, Looking for solution 1172+[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 s89)+Fast allSat, Looking for solution 1173+[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 s61)+Fast allSat, Looking for solution 1174+[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 s62)+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 s64)+[GOOD] (assert s83)+Fast allSat, Looking for solution 1175+[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 s62)+Fast allSat, Looking for solution 1176+[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 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 11))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[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 11))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[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 11))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s89)+Fast allSat, Looking for solution 1180+[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 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 11))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1182+[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 s67)+Fast allSat, Looking for solution 1183+[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 s68)+Fast allSat, Looking for solution 1184+[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 s69)+Fast allSat, Looking for solution 1185+[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 s70)+Fast allSat, Looking for solution 1186+[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 s71)+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 s64)+[GOOD] (assert s82)+Fast allSat, Looking for solution 1187+[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 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 10))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[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 10))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[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 10))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[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 10))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[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 10))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1193+[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 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 10))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1195+[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 s60)+Fast allSat, Looking for solution 1196+[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 s58)+Fast allSat, Looking for solution 1197+[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 s72)+Fast allSat, Looking for solution 1198+[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 s89)+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 s71)+[GOOD] (assert s74)+Fast allSat, Looking for solution 1199+[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 s89)+Fast allSat, Looking for solution 1200+[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 s72)+Fast allSat, Looking for solution 1201+[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 s58)+Fast allSat, Looking for solution 1202+[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 s60)+Fast allSat, Looking for solution 1203+[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 s61)+Fast allSat, Looking for solution 1204+[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 s62)+Fast allSat, Looking for solution 1205+[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 s64)+Fast allSat, Looking for solution 1206+[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 s65)+Fast allSat, Looking for solution 1207+[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 s66)+Fast allSat, Looking for solution 1208+[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 s67)+Fast allSat, Looking for solution 1209+[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 s68)+Fast allSat, Looking for solution 1210+[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 s69)+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 s70)+[GOOD] (assert s75)+Fast allSat, Looking for solution 1211+[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 s68)+Fast allSat, Looking for solution 1212+[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 s67)+Fast allSat, Looking for solution 1213+[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 s66)+Fast allSat, Looking for solution 1214+[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 s65)+Fast allSat, Looking for solution 1215+[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 s64)+Fast allSat, Looking for solution 1216+[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 s62)+Fast allSat, Looking for solution 1217+[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 s61)+Fast allSat, Looking for solution 1218+[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 s60)+Fast allSat, Looking for solution 1219+[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 s58)+Fast allSat, Looking for solution 1220+[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 s72)+Fast allSat, Looking for solution 1221+[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 s89)+Fast allSat, Looking for solution 1222+[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 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 s69)+[GOOD] (assert s76)+Fast allSat, Looking for solution 1223+[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 s71)+Fast allSat, Looking for solution 1224+[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 s70)+Fast allSat, Looking for solution 1225+[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 s62)+Fast allSat, Looking for solution 1226+[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 s61)+Fast allSat, Looking for solution 1227+[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 s60)+Fast allSat, Looking for solution 1228+[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 s58)+Fast allSat, Looking for solution 1229+[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 s72)+Fast allSat, Looking for solution 1230+[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 s89)+Fast allSat, Looking for solution 1231+[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 s64)+Fast allSat, Looking for solution 1232+[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 s65)+Fast allSat, Looking for solution 1233+[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 s66)+Fast allSat, Looking for solution 1234+[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 s67)+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 s68)+[GOOD] (assert s77)+Fast allSat, Looking for solution 1235+[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 s64)+Fast allSat, Looking for solution 1236+[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 s65)+Fast allSat, Looking for solution 1237+[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 s66)+Fast allSat, Looking for solution 1238+[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 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 5))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[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 5))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[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 5))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[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 5))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[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 5))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s89)+Fast allSat, Looking for solution 1244+[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 s69)+Fast allSat, Looking for solution 1245+[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 s70)+Fast allSat, Looking for solution 1246+[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 s71)+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 s67)+[GOOD] (assert s78)+Fast allSat, Looking for solution 1247+[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 s71)+Fast allSat, Looking for solution 1248+[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 s70)+Fast allSat, Looking for solution 1249+[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 s69)+Fast allSat, Looking for solution 1250+[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 s68)+Fast allSat, Looking for solution 1251+[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 s62)+Fast allSat, Looking for solution 1252+[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 s61)+Fast allSat, Looking for solution 1253+[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 s60)+Fast allSat, Looking for solution 1254+[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 s58)+Fast allSat, Looking for solution 1255+[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 s72)+Fast allSat, Looking for solution 1256+[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 s89)+Fast allSat, Looking for solution 1257+[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 s64)+Fast allSat, Looking for solution 1258+[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 s65)+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 s66)+[GOOD] (assert s79)+Fast allSat, Looking for solution 1259+[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 s64)+Fast allSat, Looking for solution 1260+[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 s62)+Fast allSat, Looking for solution 1261+[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 s61)+Fast allSat, Looking for solution 1262+[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 s60)+Fast allSat, Looking for solution 1263+[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 s58)+Fast allSat, Looking for solution 1264+[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 s72)+Fast allSat, Looking for solution 1265+[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 s89)+Fast allSat, Looking for solution 1266+[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 s67)+Fast allSat, Looking for solution 1267+[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 s68)+Fast allSat, Looking for solution 1268+[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 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 7))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[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 7))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s71)+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 s62)+[GOOD] (assert s94)+[GOOD] (assert s80)+Fast allSat, Looking for solution 1271+[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 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 8))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1273+[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 s69)+Fast allSat, Looking for solution 1274+[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 s68)+Fast allSat, Looking for solution 1275+[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 s67)+Fast allSat, Looking for solution 1276+[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 s66)+Fast allSat, Looking for solution 1277+[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 s65)+Fast allSat, Looking for solution 1278+[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 s61)+Fast allSat, Looking for solution 1279+[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 s60)+Fast allSat, Looking for solution 1280+[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 s58)+Fast allSat, Looking for solution 1281+[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 s72)+Fast allSat, Looking for solution 1282+[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 s89)+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 s50)+[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 6))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s51)+Fast allSat, Looking for solution 1284+[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 s52)+Fast allSat, Looking for solution 1285+[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 s53)+Fast allSat, Looking for solution 1286+[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 s54)+Fast allSat, Looking for solution 1287+[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 s55)+Fast allSat, Looking for solution 1288+[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 s56)+Fast allSat, Looking for solution 1289+[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 s48)+Fast allSat, Looking for solution 1290+[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 s47)+Fast allSat, Looking for solution 1291+[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 s46)+Fast allSat, Looking for solution 1292+[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 s45)+Fast allSat, Looking for solution 1293+[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 s43)+Fast allSat, Looking for solution 1294+[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 s57)+Fast allSat, Looking for solution 1295+[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 s87)+Fast allSat, Looking for solution 1296+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1296+[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 s58)+Fast allSat, Looking for solution 1297+[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 s60)+Fast allSat, Looking for solution 1298+[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 s61)+Fast allSat, Looking for solution 1299+[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 s62)+Fast allSat, Looking for solution 1300+[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 s63)+Fast allSat, Looking for solution 1301+[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 s65)+Fast allSat, Looking for solution 1302+[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 s66)+Fast allSat, Looking for solution 1303+[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 s67)+Fast allSat, Looking for solution 1304+[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 s68)+Fast allSat, Looking for solution 1305+[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 s69)+Fast allSat, Looking for solution 1306+[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 s70)+Fast allSat, Looking for solution 1307+[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 s71)+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 s89)+[GOOD] (assert s59)+Fast allSat, Looking for solution 1308+[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 s65)+Fast allSat, Looking for solution 1309+[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 s66)+Fast allSat, Looking for solution 1310+[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 s67)+Fast allSat, Looking for solution 1311+[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 s68)+Fast allSat, Looking for solution 1312+[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 s69)+Fast allSat, Looking for solution 1313+[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 s70)+Fast allSat, Looking for solution 1314+[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 s71)+Fast allSat, Looking for solution 1315+[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 s63)+Fast allSat, Looking for solution 1316+[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 s62)+Fast allSat, Looking for solution 1317+[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 s61)+Fast allSat, Looking for solution 1318+[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 s60)+Fast allSat, Looking for solution 1319+[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 s58)+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 s89)+[GOOD] (assert s85)+Fast allSat, Looking for solution 1320+[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 s60)+Fast allSat, Looking for solution 1321+[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 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 13))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[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 13))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[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 13))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1325+[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 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 13))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[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 13))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[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 13))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[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 13))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[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 13))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[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 13))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[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 s89)+[GOOD] (assert s84)+Fast allSat, Looking for solution 1332+[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 s58)+Fast allSat, Looking for solution 1333+[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 s72)+Fast allSat, Looking for solution 1334+[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 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 12))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 1336+[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 s63)+Fast allSat, Looking for solution 1337+[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 s65)+Fast allSat, Looking for solution 1338+[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 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 12))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[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 12))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[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 12))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[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 12))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[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 12))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[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 s89)+[GOOD] (assert s83)+Fast allSat, Looking for solution 1344+[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 s65)+Fast allSat, Looking for solution 1345+[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 s66)+Fast allSat, Looking for solution 1346+[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 s67)+Fast allSat, Looking for solution 1347+[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 s68)+Fast allSat, Looking for solution 1348+[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 s69)+Fast allSat, Looking for solution 1349+[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 s70)+Fast allSat, Looking for solution 1350+[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 s71)+Fast allSat, Looking for solution 1351+[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 s63)+Fast allSat, Looking for solution 1352+[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 s62)+Fast allSat, Looking for solution 1353+[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 s60)+Fast allSat, Looking for solution 1354+[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 s58)+Fast allSat, Looking for solution 1355+[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 s72)+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 s89)+[GOOD] (assert s82)+Fast allSat, Looking for solution 1356+[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 s72)+Fast allSat, Looking for solution 1357+[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 s58)+Fast allSat, Looking for solution 1358+[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 s60)+Fast allSat, Looking for solution 1359+[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 s61)+Fast allSat, Looking for solution 1360+[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 s63)+Fast allSat, Looking for solution 1361+[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 s65)+Fast allSat, Looking for solution 1362+[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 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 10))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1364+[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 s68)+Fast allSat, Looking for solution 1365+[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 s69)+Fast allSat, Looking for solution 1366+[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 s70)+Fast allSat, Looking for solution 1367+[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 s71)+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 s89)+[GOOD] (assert s81)+Fast allSat, Looking for solution 1368+[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 s65)+Fast allSat, Looking for solution 1369+[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 s66)+Fast allSat, Looking for solution 1370+[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 s67)+Fast allSat, Looking for solution 1371+[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 s68)+Fast allSat, Looking for solution 1372+[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 s69)+Fast allSat, Looking for solution 1373+[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 s70)+Fast allSat, Looking for solution 1374+[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 s71)+Fast allSat, Looking for solution 1375+[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 10))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 1376+[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 s61)+Fast allSat, Looking for solution 1377+[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 s60)+Fast allSat, Looking for solution 1378+[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 s58)+Fast allSat, Looking for solution 1379+[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 s72)+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 s89)+[GOOD] (assert s73)+Fast allSat, Looking for solution 1380+[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 s72)+Fast allSat, Looking for solution 1381+[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 s58)+Fast allSat, Looking for solution 1382+[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 s60)+Fast allSat, Looking for solution 1383+[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 s61)+Fast allSat, Looking for solution 1384+[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 s62)+Fast allSat, Looking for solution 1385+[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 s63)+Fast allSat, Looking for solution 1386+[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 s65)+Fast allSat, Looking for solution 1387+[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 s66)+Fast allSat, Looking for solution 1388+[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 s67)+Fast allSat, Looking for solution 1389+[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 s68)+Fast allSat, Looking for solution 1390+[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 s69)+Fast allSat, Looking for solution 1391+[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 s70)+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 s89)+[GOOD] (assert s74)+Fast allSat, Looking for solution 1392+[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 s65)+Fast allSat, Looking for solution 1393+[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 s66)+Fast allSat, Looking for solution 1394+[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 s67)+Fast allSat, Looking for solution 1395+[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 s68)+Fast allSat, Looking for solution 1396+[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 s69)+Fast allSat, Looking for solution 1397+[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 s71)+Fast allSat, Looking for solution 1398+[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 s63)+Fast allSat, Looking for solution 1399+[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 s62)+Fast allSat, Looking for solution 1400+[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 s61)+Fast allSat, Looking for solution 1401+[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 s60)+Fast allSat, Looking for solution 1402+[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 s58)+Fast allSat, Looking for solution 1403+[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 s72)+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 s89)+[GOOD] (assert s75)+Fast allSat, Looking for solution 1404+[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 s72)+Fast allSat, Looking for solution 1405+[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 s58)+Fast allSat, Looking for solution 1406+[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 s60)+Fast allSat, Looking for solution 1407+[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 s61)+Fast allSat, Looking for solution 1408+[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 s62)+Fast allSat, Looking for solution 1409+[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 s63)+Fast allSat, Looking for solution 1410+[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 s65)+Fast allSat, Looking for solution 1411+[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 s66)+Fast allSat, Looking for solution 1412+[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 s67)+Fast allSat, Looking for solution 1413+[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 s68)+Fast allSat, Looking for solution 1414+[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 s70)+Fast allSat, Looking for solution 1415+[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 s71)+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 s89)+[GOOD] (assert s76)+Fast allSat, Looking for solution 1416+[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 s63)+Fast allSat, Looking for solution 1417+[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 s62)+Fast allSat, Looking for solution 1418+[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 s61)+Fast allSat, Looking for solution 1419+[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 s65)+Fast allSat, Looking for solution 1420+[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 s60)+Fast allSat, Looking for solution 1421+[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 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 4))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1423+[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 s67)+Fast allSat, Looking for solution 1424+[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 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 4))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1426+[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 s70)+Fast allSat, Looking for solution 1427+[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 s71)+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 s89)+[GOOD] (assert s77)+Fast allSat, Looking for solution 1428+[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 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 5))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[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 5))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[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 5))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1432+[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 s60)+Fast allSat, Looking for solution 1433+[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 s66)+Fast allSat, Looking for solution 1434+[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 s58)+Fast allSat, Looking for solution 1435+[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 s68)+Fast allSat, Looking for solution 1436+[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 s72)+Fast allSat, Looking for solution 1437+[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 s69)+Fast allSat, Looking for solution 1438+[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 s70)+Fast allSat, Looking for solution 1439+[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 s71)+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 s89)+[GOOD] (assert s78)+Fast allSat, Looking for solution 1440+[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 s63)+Fast allSat, Looking for solution 1441+[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 s62)+Fast allSat, Looking for solution 1442+[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 s61)+Fast allSat, Looking for solution 1443+[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 s65)+Fast allSat, Looking for solution 1444+[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 s60)+Fast allSat, Looking for solution 1445+[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 s67)+Fast allSat, Looking for solution 1446+[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 s58)+Fast allSat, Looking for solution 1447+[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 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 6))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[GOOD] (push 1)+[GOOD] (assert s72)+Fast allSat, Looking for solution 1449+[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 s69)+Fast allSat, Looking for solution 1450+[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 s70)+Fast allSat, Looking for solution 1451+[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 s71)+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 s63)+[GOOD] (assert s95)+[GOOD] (assert s79)+Fast allSat, Looking for solution 1452+[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 s62)+Fast allSat, Looking for solution 1453+[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 s61)+Fast allSat, Looking for solution 1454+[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 s66)+Fast allSat, Looking for solution 1455+[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 s60)+Fast allSat, Looking for solution 1456+[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 s67)+Fast allSat, Looking for solution 1457+[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 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 7))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1459+[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 s72)+Fast allSat, Looking for solution 1460+[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 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 7))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s89)+Fast allSat, Looking for solution 1462+[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 s70)+Fast allSat, Looking for solution 1463+[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 s71)+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 s51)+[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 5))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s52)+Fast allSat, Looking for solution 1465+[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 s53)+Fast allSat, Looking for solution 1466+[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 s54)+Fast allSat, Looking for solution 1467+[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 s55)+Fast allSat, Looking for solution 1468+[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 s56)+Fast allSat, Looking for solution 1469+[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 9))+[GOOD] (push 1)+[GOOD] (assert s49)+Fast allSat, Looking for solution 1470+[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 s48)+Fast allSat, Looking for solution 1471+[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 s47)+Fast allSat, Looking for solution 1472+[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 s46)+Fast allSat, Looking for solution 1473+[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 s45)+Fast allSat, Looking for solution 1474+[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 s43)+Fast allSat, Looking for solution 1475+[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 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 s87)+Fast allSat, Looking for solution 1477+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s88)+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 s58)+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 s60)+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 s61)+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 s62)+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 s63)+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 s64)+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 s66)+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 s67)+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 s68)+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 s69)+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 s70)+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 s71)+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 s89)+[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 14))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 1490+[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 s63)+Fast allSat, Looking for solution 1491+[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 s62)+Fast allSat, Looking for solution 1492+[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 s66)+Fast allSat, Looking for solution 1493+[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 s61)+Fast allSat, Looking for solution 1494+[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 s67)+Fast allSat, Looking for solution 1495+[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 s60)+Fast allSat, Looking for solution 1496+[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 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 14))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1498+[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 s69)+Fast allSat, Looking for solution 1499+[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 s70)+Fast allSat, Looking for solution 1500+[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 s71)+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 s72)+[GOOD] (assert s85)+Fast allSat, Looking for solution 1501+[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 s89)+Fast allSat, Looking for solution 1502+[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 s60)+Fast allSat, Looking for solution 1503+[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 s61)+Fast allSat, Looking for solution 1504+[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 s62)+Fast allSat, Looking for solution 1505+[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 s63)+Fast allSat, Looking for solution 1506+[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 s64)+Fast allSat, Looking for solution 1507+[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 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 13))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1509+[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 s68)+Fast allSat, Looking for solution 1510+[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 s69)+Fast allSat, Looking for solution 1511+[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 s70)+Fast allSat, Looking for solution 1512+[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 s71)+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 s58)+[GOOD] (assert s84)+Fast allSat, Looking for solution 1513+[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 s72)+Fast allSat, Looking for solution 1514+[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 s89)+Fast allSat, Looking for solution 1515+[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 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 12))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[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 12))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[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 12))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 1519+[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 s66)+Fast allSat, Looking for solution 1520+[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 s67)+Fast allSat, Looking for solution 1521+[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 s68)+Fast allSat, Looking for solution 1522+[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 s69)+Fast allSat, Looking for solution 1523+[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 s70)+Fast allSat, Looking for solution 1524+[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 s71)+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 s60)+[GOOD] (assert s83)+Fast allSat, Looking for solution 1525+[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 s58)+Fast allSat, Looking for solution 1526+[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 s72)+Fast allSat, Looking for solution 1527+[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 s62)+Fast allSat, Looking for solution 1528+[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 s89)+Fast allSat, Looking for solution 1529+[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 s63)+Fast allSat, Looking for solution 1530+[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 s64)+Fast allSat, Looking for solution 1531+[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 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 11))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1533+[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 s68)+Fast allSat, Looking for solution 1534+[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 s69)+Fast allSat, Looking for solution 1535+[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 s70)+Fast allSat, Looking for solution 1536+[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 s71)+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 s61)+[GOOD] (assert s82)+Fast allSat, Looking for solution 1537+[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 s60)+Fast allSat, Looking for solution 1538+[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 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 10))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 1540+[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 s72)+Fast allSat, Looking for solution 1541+[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 s64)+Fast allSat, Looking for solution 1542+[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 s89)+Fast allSat, Looking for solution 1543+[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 s66)+Fast allSat, Looking for solution 1544+[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 s67)+Fast allSat, Looking for solution 1545+[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 s68)+Fast allSat, Looking for solution 1546+[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 s69)+Fast allSat, Looking for solution 1547+[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 s70)+Fast allSat, Looking for solution 1548+[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 s71)+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 s62)+[GOOD] (assert s81)+Fast allSat, Looking for solution 1549+[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 s61)+Fast allSat, Looking for solution 1550+[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 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 9))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 1552+[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 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 9))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1554+[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 s72)+Fast allSat, Looking for solution 1555+[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 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 9))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s89)+Fast allSat, Looking for solution 1557+[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 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 9))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[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 9))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[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 9))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[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 s63)+[GOOD] (assert s80)+Fast allSat, Looking for solution 1561+[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 s62)+Fast allSat, Looking for solution 1562+[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 s61)+Fast allSat, Looking for solution 1563+[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 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 8))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1565+[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 s67)+Fast allSat, Looking for solution 1566+[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 s58)+Fast allSat, Looking for solution 1567+[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 s68)+Fast allSat, Looking for solution 1568+[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 s72)+Fast allSat, Looking for solution 1569+[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 s69)+Fast allSat, Looking for solution 1570+[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 s89)+Fast allSat, Looking for solution 1571+[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 s70)+Fast allSat, Looking for solution 1572+[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 s71)+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 s64)+[GOOD] (assert s73)+Fast allSat, Looking for solution 1573+[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 s63)+Fast allSat, Looking for solution 1574+[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 s62)+Fast allSat, Looking for solution 1575+[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 s66)+Fast allSat, Looking for solution 1576+[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 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 1))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1578+[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 s60)+Fast allSat, Looking for solution 1579+[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 s68)+Fast allSat, Looking for solution 1580+[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 s58)+Fast allSat, Looking for solution 1581+[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 s69)+Fast allSat, Looking for solution 1582+[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 s72)+Fast allSat, Looking for solution 1583+[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 s70)+Fast allSat, Looking for solution 1584+[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 s89)+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 s64)+[GOOD] (assert s74)+Fast allSat, Looking for solution 1585+[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 s72)+Fast allSat, Looking for solution 1586+[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 s58)+Fast allSat, Looking for solution 1587+[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 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 2))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s89)+Fast allSat, Looking for solution 1589+[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 s61)+Fast allSat, Looking for solution 1590+[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 s62)+Fast allSat, Looking for solution 1591+[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 s63)+Fast allSat, Looking for solution 1592+[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 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 2))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[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 2))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[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 2))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1596+[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 s71)+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 s64)+[GOOD] (assert s75)+Fast allSat, Looking for solution 1597+[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 s63)+Fast allSat, Looking for solution 1598+[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 s62)+Fast allSat, Looking for solution 1599+[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 s66)+Fast allSat, Looking for solution 1600+[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 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 3))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1602+[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 s60)+Fast allSat, Looking for solution 1603+[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 s68)+Fast allSat, Looking for solution 1604+[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 s58)+Fast allSat, Looking for solution 1605+[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 s70)+Fast allSat, Looking for solution 1606+[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 s72)+Fast allSat, Looking for solution 1607+[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 s71)+Fast allSat, Looking for solution 1608+[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 s89)+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 s64)+[GOOD] (assert s76)+Fast allSat, Looking for solution 1609+[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 s72)+Fast allSat, Looking for solution 1610+[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 s58)+Fast allSat, Looking for solution 1611+[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 s60)+Fast allSat, Looking for solution 1612+[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 s89)+Fast allSat, Looking for solution 1613+[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 s61)+Fast allSat, Looking for solution 1614+[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 s62)+Fast allSat, Looking for solution 1615+[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 s63)+Fast allSat, Looking for solution 1616+[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 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 4))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1618+[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 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 4))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1620+[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 s71)+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 s64)+[GOOD] (assert s77)+Fast allSat, Looking for solution 1621+[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 s63)+Fast allSat, Looking for solution 1622+[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 s62)+Fast allSat, Looking for solution 1623+[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 s66)+Fast allSat, Looking for solution 1624+[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 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 5))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 1626+[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 s60)+Fast allSat, Looking for solution 1627+[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 s69)+Fast allSat, Looking for solution 1628+[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 s58)+Fast allSat, Looking for solution 1629+[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 s70)+Fast allSat, Looking for solution 1630+[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 s72)+Fast allSat, Looking for solution 1631+[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 s71)+Fast allSat, Looking for solution 1632+[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 s89)+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 s64)+[GOOD] (assert s96)+[GOOD] (assert s78)+Fast allSat, Looking for solution 1633+[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 s72)+Fast allSat, Looking for solution 1634+[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 s58)+Fast allSat, Looking for solution 1635+[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 s60)+Fast allSat, Looking for solution 1636+[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 s89)+Fast allSat, Looking for solution 1637+[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 s61)+Fast allSat, Looking for solution 1638+[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 s62)+Fast allSat, Looking for solution 1639+[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 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 6))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1641+[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 s68)+Fast allSat, Looking for solution 1642+[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 s69)+Fast allSat, Looking for solution 1643+[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 s70)+Fast allSat, Looking for solution 1644+[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 s71)+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 s52)+[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 4))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s53)+Fast allSat, Looking for solution 1646+[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 s54)+Fast allSat, Looking for solution 1647+[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 s55)+Fast allSat, Looking for solution 1648+[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 s56)+Fast allSat, Looking for solution 1649+[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 8))+[GOOD] (push 1)+[GOOD] (assert s50)+Fast allSat, Looking for solution 1650+[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 s49)+Fast allSat, Looking for solution 1651+[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 s48)+Fast allSat, Looking for solution 1652+[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 s47)+Fast allSat, Looking for solution 1653+[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 s46)+Fast allSat, Looking for solution 1654+[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 s45)+Fast allSat, Looking for solution 1655+[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 s43)+Fast allSat, Looking for solution 1656+[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 s57)+Fast allSat, Looking for solution 1657+[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 s87)+Fast allSat, Looking for solution 1658+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1658+[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 s58)+Fast allSat, Looking for solution 1659+[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 s60)+Fast allSat, Looking for solution 1660+[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 s61)+Fast allSat, Looking for solution 1661+[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 s62)+Fast allSat, Looking for solution 1662+[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 s63)+Fast allSat, Looking for solution 1663+[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 s64)+Fast allSat, Looking for solution 1664+[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 s65)+Fast allSat, Looking for solution 1665+[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 s67)+Fast allSat, Looking for solution 1666+[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 s68)+Fast allSat, Looking for solution 1667+[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 s69)+Fast allSat, Looking for solution 1668+[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 s70)+Fast allSat, Looking for solution 1669+[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 s71)+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 s89)+[GOOD] (assert s59)+Fast allSat, Looking for solution 1670+[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 s65)+Fast allSat, Looking for solution 1671+[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 s64)+Fast allSat, Looking for solution 1672+[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 s63)+Fast allSat, Looking for solution 1673+[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 s67)+Fast allSat, Looking for solution 1674+[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 s62)+Fast allSat, Looking for solution 1675+[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 s68)+Fast allSat, Looking for solution 1676+[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 s61)+Fast allSat, Looking for solution 1677+[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 s69)+Fast allSat, Looking for solution 1678+[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 s60)+Fast allSat, Looking for solution 1679+[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 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 14))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[GOOD] (push 1)+[GOOD] (assert s58)+Fast allSat, Looking for solution 1681+[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 s71)+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 s85)+Fast allSat, Looking for solution 1682+[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 s89)+Fast allSat, Looking for solution 1683+[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 s60)+Fast allSat, Looking for solution 1684+[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 s61)+Fast allSat, Looking for solution 1685+[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 s62)+Fast allSat, Looking for solution 1686+[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 s63)+Fast allSat, Looking for solution 1687+[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 s64)+Fast allSat, Looking for solution 1688+[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 s65)+Fast allSat, Looking for solution 1689+[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 s67)+Fast allSat, Looking for solution 1690+[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 s68)+Fast allSat, Looking for solution 1691+[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 s69)+Fast allSat, Looking for solution 1692+[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 s70)+Fast allSat, Looking for solution 1693+[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 s71)+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 s58)+[GOOD] (assert s84)+Fast allSat, Looking for solution 1694+[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 s72)+Fast allSat, Looking for solution 1695+[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 s89)+Fast allSat, Looking for solution 1696+[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 s61)+Fast allSat, Looking for solution 1697+[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 s62)+Fast allSat, Looking for solution 1698+[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 s63)+Fast allSat, Looking for solution 1699+[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 s64)+Fast allSat, Looking for solution 1700+[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 s65)+Fast allSat, Looking for solution 1701+[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 s67)+Fast allSat, Looking for solution 1702+[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 s68)+Fast allSat, Looking for solution 1703+[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 s69)+Fast allSat, Looking for solution 1704+[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 s70)+Fast allSat, Looking for solution 1705+[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 s71)+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 s60)+[GOOD] (assert s83)+Fast allSat, Looking for solution 1706+[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 s67)+Fast allSat, Looking for solution 1707+[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 s68)+Fast allSat, Looking for solution 1708+[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 s69)+Fast allSat, Looking for solution 1709+[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 s70)+Fast allSat, Looking for solution 1710+[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 s71)+Fast allSat, Looking for solution 1711+[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 s65)+Fast allSat, Looking for solution 1712+[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 s64)+Fast allSat, Looking for solution 1713+[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 s63)+Fast allSat, Looking for solution 1714+[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 s62)+Fast allSat, Looking for solution 1715+[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 s58)+Fast allSat, Looking for solution 1716+[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 s72)+Fast allSat, Looking for solution 1717+[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 s89)+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 s61)+[GOOD] (assert s82)+Fast allSat, Looking for solution 1718+[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 s89)+Fast allSat, Looking for solution 1719+[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 s72)+Fast allSat, Looking for solution 1720+[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 s58)+Fast allSat, Looking for solution 1721+[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 s60)+Fast allSat, Looking for solution 1722+[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 s63)+Fast allSat, Looking for solution 1723+[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 s64)+Fast allSat, Looking for solution 1724+[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 s65)+Fast allSat, Looking for solution 1725+[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 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 10))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[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 10))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[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 10))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[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 10))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[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 s62)+[GOOD] (assert s81)+Fast allSat, Looking for solution 1730+[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 s67)+Fast allSat, Looking for solution 1731+[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 s68)+Fast allSat, Looking for solution 1732+[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 s69)+Fast allSat, Looking for solution 1733+[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 s70)+Fast allSat, Looking for solution 1734+[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 s71)+Fast allSat, Looking for solution 1735+[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 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 9))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 1737+[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 s61)+Fast allSat, Looking for solution 1738+[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 s60)+Fast allSat, Looking for solution 1739+[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 s58)+Fast allSat, Looking for solution 1740+[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 s72)+Fast allSat, Looking for solution 1741+[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 s89)+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 s63)+[GOOD] (assert s80)+Fast allSat, Looking for solution 1742+[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 s89)+Fast allSat, Looking for solution 1743+[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 s72)+Fast allSat, Looking for solution 1744+[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 s58)+Fast allSat, Looking for solution 1745+[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 s60)+Fast allSat, Looking for solution 1746+[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 s61)+Fast allSat, Looking for solution 1747+[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 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 8))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1749+[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 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 8))+[SEND] (get-value (s2))+[RECV] ((s2 4))+[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 8))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[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 8))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1753+[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 s71)+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 s64)+[GOOD] (assert s79)+Fast allSat, Looking for solution 1754+[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 s67)+Fast allSat, Looking for solution 1755+[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 s68)+Fast allSat, Looking for solution 1756+[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 s69)+Fast allSat, Looking for solution 1757+[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 s70)+Fast allSat, Looking for solution 1758+[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 s71)+Fast allSat, Looking for solution 1759+[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 s63)+Fast allSat, Looking for solution 1760+[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 s62)+Fast allSat, Looking for solution 1761+[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 s61)+Fast allSat, Looking for solution 1762+[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 s60)+Fast allSat, Looking for solution 1763+[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 s58)+Fast allSat, Looking for solution 1764+[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 s72)+Fast allSat, Looking for solution 1765+[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 s89)+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 s65)+[GOOD] (assert s73)+Fast allSat, Looking for solution 1766+[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 s89)+Fast allSat, Looking for solution 1767+[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 s72)+Fast allSat, Looking for solution 1768+[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 s58)+Fast allSat, Looking for solution 1769+[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 s60)+Fast allSat, Looking for solution 1770+[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 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 1))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 1772+[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 s63)+Fast allSat, Looking for solution 1773+[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 s64)+Fast allSat, Looking for solution 1774+[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 s67)+Fast allSat, Looking for solution 1775+[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 s68)+Fast allSat, Looking for solution 1776+[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 s69)+Fast allSat, Looking for solution 1777+[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 s70)+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 s65)+[GOOD] (assert s74)+Fast allSat, Looking for solution 1778+[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 s67)+Fast allSat, Looking for solution 1779+[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 s68)+Fast allSat, Looking for solution 1780+[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 s69)+Fast allSat, Looking for solution 1781+[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 s71)+Fast allSat, Looking for solution 1782+[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 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 2))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 1784+[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 s62)+Fast allSat, Looking for solution 1785+[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 s61)+Fast allSat, Looking for solution 1786+[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 s60)+Fast allSat, Looking for solution 1787+[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 s58)+Fast allSat, Looking for solution 1788+[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 s72)+Fast allSat, Looking for solution 1789+[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 s89)+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 s75)+Fast allSat, Looking for solution 1790+[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 s89)+Fast allSat, Looking for solution 1791+[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 s72)+Fast allSat, Looking for solution 1792+[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 s58)+Fast allSat, Looking for solution 1793+[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 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 3))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 1795+[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 s62)+Fast allSat, Looking for solution 1796+[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 s63)+Fast allSat, Looking for solution 1797+[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 s64)+Fast allSat, Looking for solution 1798+[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 s67)+Fast allSat, Looking for solution 1799+[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 s68)+Fast allSat, Looking for solution 1800+[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 s70)+Fast allSat, Looking for solution 1801+[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 s71)+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 s65)+[GOOD] (assert s76)+Fast allSat, Looking for solution 1802+[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 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 4))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[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 4))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[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 4))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 1806+[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 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 4))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 1808+[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 s62)+Fast allSat, Looking for solution 1809+[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 s61)+Fast allSat, Looking for solution 1810+[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 s60)+Fast allSat, Looking for solution 1811+[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 s58)+Fast allSat, Looking for solution 1812+[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 s72)+Fast allSat, Looking for solution 1813+[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 s89)+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 s77)+Fast allSat, Looking for solution 1814+[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 s89)+Fast allSat, Looking for solution 1815+[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 s72)+Fast allSat, Looking for solution 1816+[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 s58)+Fast allSat, Looking for solution 1817+[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 s60)+Fast allSat, Looking for solution 1818+[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 s61)+Fast allSat, Looking for solution 1819+[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 s62)+Fast allSat, Looking for solution 1820+[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 s63)+Fast allSat, Looking for solution 1821+[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 s64)+Fast allSat, Looking for solution 1822+[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 s68)+Fast allSat, Looking for solution 1823+[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 s69)+Fast allSat, Looking for solution 1824+[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 s70)+Fast allSat, Looking for solution 1825+[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 s71)+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 s53)+[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 3))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s54)+Fast allSat, Looking for solution 1827+[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 s55)+Fast allSat, Looking for solution 1828+[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 s51)+Fast allSat, Looking for solution 1829+[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 s50)+Fast allSat, Looking for solution 1830+[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 s49)+Fast allSat, Looking for solution 1831+[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 s48)+Fast allSat, Looking for solution 1832+[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 s47)+Fast allSat, Looking for solution 1833+[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 s46)+Fast allSat, Looking for solution 1834+[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 s45)+Fast allSat, Looking for solution 1835+[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 s43)+Fast allSat, Looking for solution 1836+[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 s57)+Fast allSat, Looking for solution 1837+[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 s87)+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 4))+[GOOD] (push 1)+[GOOD] (assert s56)+Fast allSat, Looking for solution 1839+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s68)+[GOOD] (assert s73)+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 3))+[GOOD] (push 1)+[GOOD] (assert s69)+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 2))+[GOOD] (push 1)+[GOOD] (assert s70)+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 6))+[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 1))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s65)+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 8))+[GOOD] (push 1)+[GOOD] (assert s64)+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 9))+[GOOD] (push 1)+[GOOD] (assert s63)+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 10))+[GOOD] (push 1)+[GOOD] (assert s62)+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 11))+[GOOD] (push 1)+[GOOD] (assert s61)+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 12))+[GOOD] (push 1)+[GOOD] (assert s60)+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 13))+[GOOD] (push 1)+[GOOD] (assert s58)+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 14))+[GOOD] (push 1)+[GOOD] (assert s72)+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 15))+[GOOD] (push 1)+[GOOD] (assert s89)+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 s68)+[GOOD] (assert s88)+Fast allSat, Looking for solution 1851+[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 s66)+Fast allSat, Looking for solution 1852+[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 s65)+Fast allSat, Looking for solution 1853+[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 s64)+Fast allSat, Looking for solution 1854+[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 s63)+Fast allSat, Looking for solution 1855+[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 s62)+Fast allSat, Looking for solution 1856+[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 s61)+Fast allSat, Looking for solution 1857+[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 s60)+Fast allSat, Looking for solution 1858+[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 s58)+Fast allSat, Looking for solution 1859+[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 s72)+Fast allSat, Looking for solution 1860+[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 s69)+Fast allSat, Looking for solution 1861+[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 s70)+Fast allSat, Looking for solution 1862+[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 s71)+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 s68)+[GOOD] (assert s59)+Fast allSat, Looking for solution 1863+[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 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 14))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 1865+[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 s69)+Fast allSat, Looking for solution 1866+[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 s89)+Fast allSat, Looking for solution 1867+[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 s58)+Fast allSat, Looking for solution 1868+[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 s60)+Fast allSat, Looking for solution 1869+[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 s61)+Fast allSat, Looking for solution 1870+[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 s62)+Fast allSat, Looking for solution 1871+[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 s63)+Fast allSat, Looking for solution 1872+[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 s64)+Fast allSat, Looking for solution 1873+[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 s65)+Fast allSat, Looking for solution 1874+[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 s66)+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 s68)+[GOOD] (assert s85)+Fast allSat, Looking for solution 1875+[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 s60)+Fast allSat, Looking for solution 1876+[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 s61)+Fast allSat, Looking for solution 1877+[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 s62)+Fast allSat, Looking for solution 1878+[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 s63)+Fast allSat, Looking for solution 1879+[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 s64)+Fast allSat, Looking for solution 1880+[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 s65)+Fast allSat, Looking for solution 1881+[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 s66)+Fast allSat, Looking for solution 1882+[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 s72)+Fast allSat, Looking for solution 1883+[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 s89)+Fast allSat, Looking for solution 1884+[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 s69)+Fast allSat, Looking for solution 1885+[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 s70)+Fast allSat, Looking for solution 1886+[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 s71)+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 s68)+[GOOD] (assert s84)+Fast allSat, Looking for solution 1887+[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 s71)+Fast allSat, Looking for solution 1888+[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 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 12))+[SEND] (get-value (s2))+[RECV] ((s2 3))+[GOOD] (push 1)+[GOOD] (assert s69)+Fast allSat, Looking for solution 1890+[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 s58)+Fast allSat, Looking for solution 1891+[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 s72)+Fast allSat, Looking for solution 1892+[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 s89)+Fast allSat, Looking for solution 1893+[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 s61)+Fast allSat, Looking for solution 1894+[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 s62)+Fast allSat, Looking for solution 1895+[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 s63)+Fast allSat, Looking for solution 1896+[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 s64)+Fast allSat, Looking for solution 1897+[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 s65)+Fast allSat, Looking for solution 1898+[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 s66)+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 s68)+[GOOD] (assert s83)+Fast allSat, Looking for solution 1899+[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 s62)+Fast allSat, Looking for solution 1900+[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 s63)+Fast allSat, Looking for solution 1901+[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 s64)+Fast allSat, Looking for solution 1902+[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 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 11))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 1904+[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 s60)+Fast allSat, Looking for solution 1905+[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 s58)+Fast allSat, Looking for solution 1906+[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 s72)+Fast allSat, Looking for solution 1907+[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 s89)+Fast allSat, Looking for solution 1908+[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 s69)+Fast allSat, Looking for solution 1909+[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 s70)+Fast allSat, Looking for solution 1910+[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 s71)+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 s68)+[GOOD] (assert s82)+Fast allSat, Looking for solution 1911+[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 s71)+Fast allSat, Looking for solution 1912+[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 s70)+Fast allSat, Looking for solution 1913+[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 s69)+Fast allSat, Looking for solution 1914+[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 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 10))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1916+[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 s58)+Fast allSat, Looking for solution 1917+[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 s72)+Fast allSat, Looking for solution 1918+[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 s89)+Fast allSat, Looking for solution 1919+[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 s63)+Fast allSat, Looking for solution 1920+[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 s64)+Fast allSat, Looking for solution 1921+[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 s65)+Fast allSat, Looking for solution 1922+[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 s66)+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 s68)+[GOOD] (assert s81)+Fast allSat, Looking for solution 1923+[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 s64)+Fast allSat, Looking for solution 1924+[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 s65)+Fast allSat, Looking for solution 1925+[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 s66)+Fast allSat, Looking for solution 1926+[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 s62)+Fast allSat, Looking for solution 1927+[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 s61)+Fast allSat, Looking for solution 1928+[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 s60)+Fast allSat, Looking for solution 1929+[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 s58)+Fast allSat, Looking for solution 1930+[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 s72)+Fast allSat, Looking for solution 1931+[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 s89)+Fast allSat, Looking for solution 1932+[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 s69)+Fast allSat, Looking for solution 1933+[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 s70)+Fast allSat, Looking for solution 1934+[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 s71)+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 s68)+[GOOD] (assert s80)+Fast allSat, Looking for solution 1935+[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 s71)+Fast allSat, Looking for solution 1936+[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 s70)+Fast allSat, Looking for solution 1937+[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 s69)+Fast allSat, Looking for solution 1938+[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 s63)+Fast allSat, Looking for solution 1939+[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 s62)+Fast allSat, Looking for solution 1940+[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 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 8))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[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 8))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[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 8))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[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 8))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s89)+Fast allSat, Looking for solution 1945+[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 s65)+Fast allSat, Looking for solution 1946+[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 s66)+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 s79)+Fast allSat, Looking for solution 1947+[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 s66)+Fast allSat, Looking for solution 1948+[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 s64)+Fast allSat, Looking for solution 1949+[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 s63)+Fast allSat, Looking for solution 1950+[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 s62)+Fast allSat, Looking for solution 1951+[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 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 7))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[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 7))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[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 7))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[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 7))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s89)+Fast allSat, Looking for solution 1956+[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 s69)+Fast allSat, Looking for solution 1957+[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 s70)+Fast allSat, Looking for solution 1958+[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 s71)+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 s68)+[GOOD] (assert s78)+Fast allSat, Looking for solution 1959+[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 s71)+Fast allSat, Looking for solution 1960+[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 s70)+Fast allSat, Looking for solution 1961+[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 s69)+Fast allSat, Looking for solution 1962+[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 7))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1963+[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 s64)+Fast allSat, Looking for solution 1964+[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 s63)+Fast allSat, Looking for solution 1965+[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 s62)+Fast allSat, Looking for solution 1966+[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 s61)+Fast allSat, Looking for solution 1967+[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 s60)+Fast allSat, Looking for solution 1968+[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 s58)+Fast allSat, Looking for solution 1969+[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 s72)+Fast allSat, Looking for solution 1970+[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 s89)+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 s71)+[GOOD] (assert s74)+Fast allSat, Looking for solution 1971+[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 s89)+Fast allSat, Looking for solution 1972+[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 s72)+Fast allSat, Looking for solution 1973+[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 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 2))+[SEND] (get-value (s2))+[RECV] ((s2 12))+[GOOD] (push 1)+[GOOD] (assert s60)+Fast allSat, Looking for solution 1975+[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 s61)+Fast allSat, Looking for solution 1976+[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 s62)+Fast allSat, Looking for solution 1977+[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 s63)+Fast allSat, Looking for solution 1978+[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 s64)+Fast allSat, Looking for solution 1979+[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 s65)+Fast allSat, Looking for solution 1980+[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 s66)+Fast allSat, Looking for solution 1981+[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 s68)+Fast allSat, Looking for solution 1982+[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 s69)+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 s70)+[GOOD] (assert s75)+Fast allSat, Looking for solution 1983+[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 s68)+Fast allSat, Looking for solution 1984+[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 s71)+Fast allSat, Looking for solution 1985+[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 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 3))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[GOOD] (push 1)+[GOOD] (assert s65)+Fast allSat, Looking for solution 1987+[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 s64)+Fast allSat, Looking for solution 1988+[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 s63)+Fast allSat, Looking for solution 1989+[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 s62)+Fast allSat, Looking for solution 1990+[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 s61)+Fast allSat, Looking for solution 1991+[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 s60)+Fast allSat, Looking for solution 1992+[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 s58)+Fast allSat, Looking for solution 1993+[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 s72)+Fast allSat, Looking for solution 1994+[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 s89)+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 s66)+[GOOD] (assert s98)+[GOOD] (assert s76)+Fast allSat, Looking for solution 1995+[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 s89)+Fast allSat, Looking for solution 1996+[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 s72)+Fast allSat, Looking for solution 1997+[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 s58)+Fast allSat, Looking for solution 1998+[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 s60)+Fast allSat, Looking for solution 1999+[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 s61)+Fast allSat, Looking for solution 2000+[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 s62)+Fast allSat, Looking for solution 2001+[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 s63)+Fast allSat, Looking for solution 2002+[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 s64)+Fast allSat, Looking for solution 2003+[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 s65)+Fast allSat, Looking for solution 2004+[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 s69)+Fast allSat, Looking for solution 2005+[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 s70)+Fast allSat, Looking for solution 2006+[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 s71)+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 s54)+[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 2))+[SEND] (get-value (s2))+[RECV] ((s2 1))+[GOOD] (push 1)+[GOOD] (assert s55)+Fast allSat, Looking for solution 2008+[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 s52)+Fast allSat, Looking for solution 2009+[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 s51)+Fast allSat, Looking for solution 2010+[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 s50)+Fast allSat, Looking for solution 2011+[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 s49)+Fast allSat, Looking for solution 2012+[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 s48)+Fast allSat, Looking for solution 2013+[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 s47)+Fast allSat, Looking for solution 2014+[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 s46)+Fast allSat, Looking for solution 2015+[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 s45)+Fast allSat, Looking for solution 2016+[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 s43)+Fast allSat, Looking for solution 2017+[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 s57)+Fast allSat, Looking for solution 2018+[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 s87)+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 3))+[GOOD] (push 1)+[GOOD] (assert s56)+Fast allSat, Looking for solution 2020+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s69)+[GOOD] (assert s73)+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 2))+[GOOD] (push 1)+[GOOD] (assert s70)+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 s67)+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 s66)+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 s65)+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 s64)+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 s63)+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 s62)+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 s61)+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 s60)+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 s58)+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 s72)+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 s89)+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 s69)+[GOOD] (assert s88)+Fast allSat, Looking for solution 2032+[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 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 15))+[SEND] (get-value (s2))+[RECV] ((s2 6))+[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 15))+[SEND] (get-value (s2))+[RECV] ((s2 7))+[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 15))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[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 15))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[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 15))+[SEND] (get-value (s2))+[RECV] ((s2 10))+[GOOD] (push 1)+[GOOD] (assert s62)+Fast allSat, Looking for solution 2038+[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 s61)+Fast allSat, Looking for solution 2039+[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 s60)+Fast allSat, Looking for solution 2040+[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 s58)+Fast allSat, Looking for solution 2041+[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 s72)+Fast allSat, Looking for solution 2042+[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 s70)+Fast allSat, Looking for solution 2043+[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 s71)+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 s69)+[GOOD] (assert s59)+Fast allSat, Looking for solution 2044+[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 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 14))+[SEND] (get-value (s2))+[RECV] ((s2 2))+[GOOD] (push 1)+[GOOD] (assert s70)+Fast allSat, Looking for solution 2046+[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 s67)+Fast allSat, Looking for solution 2047+[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 s66)+Fast allSat, Looking for solution 2048+[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 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 14))+[SEND] (get-value (s2))+[RECV] ((s2 8))+[GOOD] (push 1)+[GOOD] (assert s64)+Fast allSat, Looking for solution 2050+[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 s63)+Fast allSat, Looking for solution 2051+[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 s62)+Fast allSat, Looking for solution 2052+[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 s61)+Fast allSat, Looking for solution 2053+[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 s60)+Fast allSat, Looking for solution 2054+[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 s58)+Fast allSat, Looking for solution 2055+[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 s89)+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 s69)+[GOOD] (assert s85)+Fast allSat, Looking for solution 2056+[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 s72)+Fast allSat, Looking for solution 2057+[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 s89)+Fast allSat, Looking for solution 2058+[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 s60)+Fast allSat, Looking for solution 2059+[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 s61)+Fast allSat, Looking for solution 2060+[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 s62)+Fast allSat, Looking for solution 2061+[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 s63)+Fast allSat, Looking for solution 2062+[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 s64)+Fast allSat, Looking for solution 2063+[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 s65)+Fast allSat, Looking for solution 2064+[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 s66)+Fast allSat, Looking for solution 2065+[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 s67)+Fast allSat, Looking for solution 2066+[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 s70)+Fast allSat, Looking for solution 2067+[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 s71)+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 s69)+[GOOD] (assert s84)+Fast allSat, Looking for solution 2068+[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 s71)+Fast allSat, Looking for solution 2069+[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 s70)+Fast allSat, Looking for solution 2070+[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 s58)+Fast allSat, Looking for solution 2071+[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 s72)+Fast allSat, Looking for solution 2072+[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 s89)+Fast allSat, Looking for solution 2073+[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 s61)+Fast allSat, Looking for solution 2074+[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 s62)+Fast allSat, Looking for solution 2075+[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 s63)+Fast allSat, Looking for solution 2076+[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 s64)+Fast allSat, Looking for solution 2077+[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 s65)+Fast allSat, Looking for solution 2078+[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 s66)+Fast allSat, Looking for solution 2079+[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 s67)+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 s83)+Fast allSat, Looking for solution 2080+[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 s62)+Fast allSat, Looking for solution 2081+[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 s63)+Fast allSat, Looking for solution 2082+[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 s64)+Fast allSat, Looking for solution 2083+[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 s65)+Fast allSat, Looking for solution 2084+[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 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 11))+[SEND] (get-value (s2))+[RECV] ((s2 5))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 2086+[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 s60)+Fast allSat, Looking for solution 2087+[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 s58)+Fast allSat, Looking for solution 2088+[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 s72)+Fast allSat, Looking for solution 2089+[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 s89)+Fast allSat, Looking for solution 2090+[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 s70)+Fast allSat, Looking for solution 2091+[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 s71)+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 s69)+[GOOD] (assert s82)+Fast allSat, Looking for solution 2092+[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 s71)+Fast allSat, Looking for solution 2093+[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 s70)+Fast allSat, Looking for solution 2094+[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 s61)+Fast allSat, Looking for solution 2095+[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 s60)+Fast allSat, Looking for solution 2096+[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 s58)+Fast allSat, Looking for solution 2097+[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 s72)+Fast allSat, Looking for solution 2098+[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 s89)+Fast allSat, Looking for solution 2099+[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 s63)+Fast allSat, Looking for solution 2100+[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 s64)+Fast allSat, Looking for solution 2101+[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 s65)+Fast allSat, Looking for solution 2102+[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 s66)+Fast allSat, Looking for solution 2103+[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 s67)+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 s69)+[GOOD] (assert s81)+Fast allSat, Looking for solution 2104+[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 s64)+Fast allSat, Looking for solution 2105+[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 s65)+Fast allSat, Looking for solution 2106+[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 s66)+Fast allSat, Looking for solution 2107+[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 s67)+Fast allSat, Looking for solution 2108+[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 s62)+Fast allSat, Looking for solution 2109+[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 s61)+Fast allSat, Looking for solution 2110+[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 s60)+Fast allSat, Looking for solution 2111+[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 s58)+Fast allSat, Looking for solution 2112+[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 s72)+Fast allSat, Looking for solution 2113+[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 s89)+Fast allSat, Looking for solution 2114+[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 s70)+Fast allSat, Looking for solution 2115+[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 s71)+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 s69)+[GOOD] (assert s80)+Fast allSat, Looking for solution 2116+[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 s71)+Fast allSat, Looking for solution 2117+[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 s70)+Fast allSat, Looking for solution 2118+[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 s63)+Fast allSat, Looking for solution 2119+[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 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 8))+[SEND] (get-value (s2))+[RECV] ((s2 11))+[GOOD] (push 1)+[GOOD] (assert s61)+Fast allSat, Looking for solution 2121+[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 s60)+Fast allSat, Looking for solution 2122+[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 s58)+Fast allSat, Looking for solution 2123+[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 s72)+Fast allSat, Looking for solution 2124+[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 s89)+Fast allSat, Looking for solution 2125+[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 s65)+Fast allSat, Looking for solution 2126+[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 s66)+Fast allSat, Looking for solution 2127+[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 s67)+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 s69)+[GOOD] (assert s79)+Fast allSat, Looking for solution 2128+[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 s66)+Fast allSat, Looking for solution 2129+[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 s67)+Fast allSat, Looking for solution 2130+[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 s64)+Fast allSat, Looking for solution 2131+[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 s63)+Fast allSat, Looking for solution 2132+[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 s62)+Fast allSat, Looking for solution 2133+[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 s61)+Fast allSat, Looking for solution 2134+[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 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 7))+[SEND] (get-value (s2))+[RECV] ((s2 13))+[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 7))+[SEND] (get-value (s2))+[RECV] ((s2 14))+[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 7))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s89)+Fast allSat, Looking for solution 2138+[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 s70)+Fast allSat, Looking for solution 2139+[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 s71)+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 s69)+[GOOD] (assert s78)+Fast allSat, Looking for solution 2140+[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 s71)+Fast allSat, Looking for solution 2141+[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 s70)+Fast allSat, Looking for solution 2142+[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 s65)+Fast allSat, Looking for solution 2143+[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 s64)+Fast allSat, Looking for solution 2144+[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 s63)+Fast allSat, Looking for solution 2145+[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 s62)+Fast allSat, Looking for solution 2146+[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 s61)+Fast allSat, Looking for solution 2147+[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 s60)+Fast allSat, Looking for solution 2148+[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 s58)+Fast allSat, Looking for solution 2149+[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 s72)+Fast allSat, Looking for solution 2150+[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 s89)+Fast allSat, Looking for solution 2151+[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 s67)+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 s69)+[GOOD] (assert s77)+Fast allSat, Looking for solution 2152+[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 6))+[GOOD] (push 1)+[GOOD] (assert s66)+Fast allSat, Looking for solution 2153+[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 s65)+Fast allSat, Looking for solution 2154+[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 s64)+Fast allSat, Looking for solution 2155+[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 s63)+Fast allSat, Looking for solution 2156+[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 s62)+Fast allSat, Looking for solution 2157+[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 s61)+Fast allSat, Looking for solution 2158+[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 s60)+Fast allSat, Looking for solution 2159+[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 s58)+Fast allSat, Looking for solution 2160+[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 s72)+Fast allSat, Looking for solution 2161+[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 s89)+Fast allSat, Looking for solution 2162+[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 s70)+Fast allSat, Looking for solution 2163+[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 s71)+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 s71)+[GOOD] (assert s74)+Fast allSat, Looking for solution 2164+[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 s67)+Fast allSat, Looking for solution 2165+[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 s66)+Fast allSat, Looking for solution 2166+[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 s65)+Fast allSat, Looking for solution 2167+[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 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 2))+[SEND] (get-value (s2))+[RECV] ((s2 9))+[GOOD] (push 1)+[GOOD] (assert s63)+Fast allSat, Looking for solution 2169+[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 s62)+Fast allSat, Looking for solution 2170+[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 s61)+Fast allSat, Looking for solution 2171+[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 s60)+Fast allSat, Looking for solution 2172+[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 s58)+Fast allSat, Looking for solution 2173+[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 s72)+Fast allSat, Looking for solution 2174+[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 s89)+Fast allSat, Looking for solution 2175+[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 s69)+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 s67)+[GOOD] (assert s99)+[GOOD] (assert s75)+Fast allSat, Looking for solution 2176+[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 s70)+Fast allSat, Looking for solution 2177+[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 s71)+Fast allSat, Looking for solution 2178+[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 s66)+Fast allSat, Looking for solution 2179+[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 s65)+Fast allSat, Looking for solution 2180+[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 s64)+Fast allSat, Looking for solution 2181+[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 s63)+Fast allSat, Looking for solution 2182+[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 s62)+Fast allSat, Looking for solution 2183+[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 s61)+Fast allSat, Looking for solution 2184+[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 s60)+Fast allSat, Looking for solution 2185+[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 s58)+Fast allSat, Looking for solution 2186+[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 s72)+Fast allSat, Looking for solution 2187+[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 s89)+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 s56)+[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 2))+[SEND] (get-value (s1))+[RECV] ((s1 3))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s54)+Fast allSat, Looking for solution 2189+[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 s53)+Fast allSat, Looking for solution 2190+[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 s52)+Fast allSat, Looking for solution 2191+[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 s51)+Fast allSat, Looking for solution 2192+[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 s50)+Fast allSat, Looking for solution 2193+[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 s49)+Fast allSat, Looking for solution 2194+[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 s48)+Fast allSat, Looking for solution 2195+[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 s47)+Fast allSat, Looking for solution 2196+[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 s46)+Fast allSat, Looking for solution 2197+[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 s45)+Fast allSat, Looking for solution 2198+[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 s43)+Fast allSat, Looking for solution 2199+[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 s57)+Fast allSat, Looking for solution 2200+[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 s87)+Fast allSat, Looking for solution 2201+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s88)+Fast allSat, Looking for solution 2201+[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 s58)+Fast allSat, Looking for solution 2202+[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 s60)+Fast allSat, Looking for solution 2203+[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 s61)+Fast allSat, Looking for solution 2204+[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 s62)+Fast allSat, Looking for solution 2205+[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 s63)+Fast allSat, Looking for solution 2206+[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 s64)+Fast allSat, Looking for solution 2207+[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 s65)+Fast allSat, Looking for solution 2208+[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 s66)+Fast allSat, Looking for solution 2209+[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 s67)+Fast allSat, Looking for solution 2210+[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 s68)+Fast allSat, Looking for solution 2211+[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 s69)+Fast allSat, Looking for solution 2212+[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 s71)+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 s89)+[GOOD] (assert s59)+Fast allSat, Looking for solution 2213+[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 s71)+Fast allSat, Looking for solution 2214+[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 s69)+Fast allSat, Looking for solution 2215+[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 s68)+Fast allSat, Looking for solution 2216+[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 s67)+Fast allSat, Looking for solution 2217+[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 s66)+Fast allSat, Looking for solution 2218+[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 s65)+Fast allSat, Looking for solution 2219+[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 s64)+Fast allSat, Looking for solution 2220+[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 s63)+Fast allSat, Looking for solution 2221+[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 s62)+Fast allSat, Looking for solution 2222+[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 s61)+Fast allSat, Looking for solution 2223+[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 s60)+Fast allSat, Looking for solution 2224+[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 s58)+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 s89)+[GOOD] (assert s85)+Fast allSat, Looking for solution 2225+[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 s60)+Fast allSat, Looking for solution 2226+[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 s61)+Fast allSat, Looking for solution 2227+[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 s62)+Fast allSat, Looking for solution 2228+[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 s63)+Fast allSat, Looking for solution 2229+[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 s64)+Fast allSat, Looking for solution 2230+[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 s65)+Fast allSat, Looking for solution 2231+[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 s66)+Fast allSat, Looking for solution 2232+[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 s67)+Fast allSat, Looking for solution 2233+[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 s68)+Fast allSat, Looking for solution 2234+[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 s69)+Fast allSat, Looking for solution 2235+[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 s72)+Fast allSat, Looking for solution 2236+[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 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 s89)+[GOOD] (assert s84)+Fast allSat, Looking for solution 2237+[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 s71)+Fast allSat, Looking for solution 2238+[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 s69)+Fast allSat, Looking for solution 2239+[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 s68)+Fast allSat, Looking for solution 2240+[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 s67)+Fast allSat, Looking for solution 2241+[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 s66)+Fast allSat, Looking for solution 2242+[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 s65)+Fast allSat, Looking for solution 2243+[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 s64)+Fast allSat, Looking for solution 2244+[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 s63)+Fast allSat, Looking for solution 2245+[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 s62)+Fast allSat, Looking for solution 2246+[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 s61)+Fast allSat, Looking for solution 2247+[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 s58)+Fast allSat, Looking for solution 2248+[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 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 s89)+[GOOD] (assert s83)+Fast allSat, Looking for solution 2249+[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 s72)+Fast allSat, Looking for solution 2250+[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 s58)+Fast allSat, Looking for solution 2251+[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 s60)+Fast allSat, Looking for solution 2252+[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 s62)+Fast allSat, Looking for solution 2253+[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 s63)+Fast allSat, Looking for solution 2254+[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 s64)+Fast allSat, Looking for solution 2255+[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 s65)+Fast allSat, Looking for solution 2256+[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 s66)+Fast allSat, Looking for solution 2257+[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 s67)+Fast allSat, Looking for solution 2258+[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 s68)+Fast allSat, Looking for solution 2259+[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 s69)+Fast allSat, Looking for solution 2260+[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 s71)+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 s89)+[GOOD] (assert s82)+Fast allSat, Looking for solution 2261+[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 s71)+Fast allSat, Looking for solution 2262+[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 s69)+Fast allSat, Looking for solution 2263+[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 s68)+Fast allSat, Looking for solution 2264+[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 s67)+Fast allSat, Looking for solution 2265+[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 s66)+Fast allSat, Looking for solution 2266+[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 s65)+Fast allSat, Looking for solution 2267+[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 s64)+Fast allSat, Looking for solution 2268+[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 s63)+Fast allSat, Looking for solution 2269+[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 s61)+Fast allSat, Looking for solution 2270+[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 s60)+Fast allSat, Looking for solution 2271+[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 s58)+Fast allSat, Looking for solution 2272+[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 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 s89)+[GOOD] (assert s81)+Fast allSat, Looking for solution 2273+[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 s72)+Fast allSat, Looking for solution 2274+[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 s58)+Fast allSat, Looking for solution 2275+[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 s60)+Fast allSat, Looking for solution 2276+[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 s61)+Fast allSat, Looking for solution 2277+[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 s62)+Fast allSat, Looking for solution 2278+[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 s64)+Fast allSat, Looking for solution 2279+[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 s65)+Fast allSat, Looking for solution 2280+[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 s66)+Fast allSat, Looking for solution 2281+[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 s67)+Fast allSat, Looking for solution 2282+[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 s68)+Fast allSat, Looking for solution 2283+[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 s69)+Fast allSat, Looking for solution 2284+[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 s71)+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 s89)+[GOOD] (assert s80)+Fast allSat, Looking for solution 2285+[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 s71)+Fast allSat, Looking for solution 2286+[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 s69)+Fast allSat, Looking for solution 2287+[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 s68)+Fast allSat, Looking for solution 2288+[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 s67)+Fast allSat, Looking for solution 2289+[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 s66)+Fast allSat, Looking for solution 2290+[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 s65)+Fast allSat, Looking for solution 2291+[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 s63)+Fast allSat, Looking for solution 2292+[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 s62)+Fast allSat, Looking for solution 2293+[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 s61)+Fast allSat, Looking for solution 2294+[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 s60)+Fast allSat, Looking for solution 2295+[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 s58)+Fast allSat, Looking for solution 2296+[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 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 s89)+[GOOD] (assert s79)+Fast allSat, Looking for solution 2297+[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 s72)+Fast allSat, Looking for solution 2298+[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 s58)+Fast allSat, Looking for solution 2299+[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 s60)+Fast allSat, Looking for solution 2300+[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 s61)+Fast allSat, Looking for solution 2301+[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 s62)+Fast allSat, Looking for solution 2302+[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 s63)+Fast allSat, Looking for solution 2303+[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 s64)+Fast allSat, Looking for solution 2304+[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 s66)+Fast allSat, Looking for solution 2305+[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 s67)+Fast allSat, Looking for solution 2306+[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 s68)+Fast allSat, Looking for solution 2307+[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 s69)+Fast allSat, Looking for solution 2308+[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 s71)+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 s89)+[GOOD] (assert s78)+Fast allSat, Looking for solution 2309+[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 s71)+Fast allSat, Looking for solution 2310+[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 s69)+Fast allSat, Looking for solution 2311+[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 s68)+Fast allSat, Looking for solution 2312+[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 s67)+Fast allSat, Looking for solution 2313+[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 s65)+Fast allSat, Looking for solution 2314+[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 s64)+Fast allSat, Looking for solution 2315+[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 s63)+Fast allSat, Looking for solution 2316+[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 s62)+Fast allSat, Looking for solution 2317+[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 s61)+Fast allSat, Looking for solution 2318+[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 s60)+Fast allSat, Looking for solution 2319+[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 s58)+Fast allSat, Looking for solution 2320+[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 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 s89)+[GOOD] (assert s77)+Fast allSat, Looking for solution 2321+[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 s72)+Fast allSat, Looking for solution 2322+[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 s58)+Fast allSat, Looking for solution 2323+[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 s60)+Fast allSat, Looking for solution 2324+[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 s61)+Fast allSat, Looking for solution 2325+[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 s62)+Fast allSat, Looking for solution 2326+[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 s63)+Fast allSat, Looking for solution 2327+[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 s64)+Fast allSat, Looking for solution 2328+[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 s65)+Fast allSat, Looking for solution 2329+[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 s66)+Fast allSat, Looking for solution 2330+[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 s68)+Fast allSat, Looking for solution 2331+[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 s69)+Fast allSat, Looking for solution 2332+[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 s71)+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 s89)+[GOOD] (assert s76)+Fast allSat, Looking for solution 2333+[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 s71)+Fast allSat, Looking for solution 2334+[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 s69)+Fast allSat, Looking for solution 2335+[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 s67)+Fast allSat, Looking for solution 2336+[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 s66)+Fast allSat, Looking for solution 2337+[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 s65)+Fast allSat, Looking for solution 2338+[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 s64)+Fast allSat, Looking for solution 2339+[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 s63)+Fast allSat, Looking for solution 2340+[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 s62)+Fast allSat, Looking for solution 2341+[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 s61)+Fast allSat, Looking for solution 2342+[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 s60)+Fast allSat, Looking for solution 2343+[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 s58)+Fast allSat, Looking for solution 2344+[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 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 s89)+[GOOD] (assert s75)+Fast allSat, Looking for solution 2345+[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 s72)+Fast allSat, Looking for solution 2346+[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 s58)+Fast allSat, Looking for solution 2347+[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 s60)+Fast allSat, Looking for solution 2348+[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 s61)+Fast allSat, Looking for solution 2349+[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 s62)+Fast allSat, Looking for solution 2350+[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 s63)+Fast allSat, Looking for solution 2351+[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 s64)+Fast allSat, Looking for solution 2352+[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 s65)+Fast allSat, Looking for solution 2353+[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 s66)+Fast allSat, Looking for solution 2354+[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 s67)+Fast allSat, Looking for solution 2355+[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 4))+[GOOD] (push 1)+[GOOD] (assert s68)+Fast allSat, Looking for solution 2356+[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 s71)+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 s69)+[GOOD] (assert s100)+[GOOD] (assert s73)+Fast allSat, Looking for solution 2357+[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 s68)+Fast allSat, Looking for solution 2358+[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 s67)+Fast allSat, Looking for solution 2359+[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 s66)+Fast allSat, Looking for solution 2360+[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 s65)+Fast allSat, Looking for solution 2361+[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 s64)+Fast allSat, Looking for solution 2362+[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 s63)+Fast allSat, Looking for solution 2363+[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 s62)+Fast allSat, Looking for solution 2364+[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 s61)+Fast allSat, Looking for solution 2365+[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 s60)+Fast allSat, Looking for solution 2366+[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 s58)+Fast allSat, Looking for solution 2367+[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 s72)+Fast allSat, Looking for solution 2368+[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 s89)+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 s56)+[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 3))+[SEND] (get-value (s1))+[RECV] ((s1 2))+[SEND] (get-value (s2))+[RECV] ((s2 15))+[GOOD] (push 1)+[GOOD] (assert s55)+Fast allSat, Looking for solution 2370+[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 s53)+Fast allSat, Looking for solution 2371+[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 s52)+Fast allSat, Looking for solution 2372+[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 s51)+Fast allSat, Looking for solution 2373+[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 s50)+Fast allSat, Looking for solution 2374+[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 s49)+Fast allSat, Looking for solution 2375+[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 s48)+Fast allSat, Looking for solution 2376+[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 s47)+Fast allSat, Looking for solution 2377+[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 s46)+Fast allSat, Looking for solution 2378+[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 s45)+Fast allSat, Looking for solution 2379+[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 s43)+Fast allSat, Looking for solution 2380+[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 s57)+Fast allSat, Looking for solution 2381+[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 s87)+Fast allSat, Looking for solution 2382+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s88)+Fast allSat, Looking for solution 2382+[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 s58)+Fast allSat, Looking for solution 2383+[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 s60)+Fast allSat, Looking for solution 2384+[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 s61)+Fast allSat, Looking for solution 2385+[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 s62)+Fast allSat, Looking for solution 2386+[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 s63)+Fast allSat, Looking for solution 2387+[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 s64)+Fast allSat, Looking for solution 2388+[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 s65)+Fast allSat, Looking for solution 2389+[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 s66)+Fast allSat, Looking for solution 2390+[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 s67)+Fast allSat, Looking for solution 2391+[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 s68)+Fast allSat, Looking for solution 2392+[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 s70)+Fast allSat, Looking for solution 2393+[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 s71)+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 s89)+[GOOD] (assert s59)+Fast allSat, Looking for solution 2394+[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 s70)+Fast allSat, Looking for solution 2395+[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 s71)+Fast allSat, Looking for solution 2396+[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 s68)+Fast allSat, Looking for solution 2397+[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 s67)+Fast allSat, Looking for solution 2398+[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 s66)+Fast allSat, Looking for solution 2399+[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 s65)+Fast allSat, Looking for solution 2400+[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 s64)+Fast allSat, Looking for solution 2401+[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 s63)+Fast allSat, Looking for solution 2402+[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 s62)+Fast allSat, Looking for solution 2403+[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 s61)+Fast allSat, Looking for solution 2404+[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 s60)+Fast allSat, Looking for solution 2405+[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 s58)+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 s89)+[GOOD] (assert s85)+Fast allSat, Looking for solution 2406+[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 s60)+Fast allSat, Looking for solution 2407+[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 s61)+Fast allSat, Looking for solution 2408+[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 s62)+Fast allSat, Looking for solution 2409+[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 s63)+Fast allSat, Looking for solution 2410+[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 s64)+Fast allSat, Looking for solution 2411+[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 s65)+Fast allSat, Looking for solution 2412+[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 s66)+Fast allSat, Looking for solution 2413+[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 s67)+Fast allSat, Looking for solution 2414+[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 s68)+Fast allSat, Looking for solution 2415+[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 s70)+Fast allSat, Looking for solution 2416+[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 s71)+Fast allSat, Looking for solution 2417+[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 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 s89)+[GOOD] (assert s84)+Fast allSat, Looking for solution 2418+[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 s58)+Fast allSat, Looking for solution 2419+[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 s72)+Fast allSat, Looking for solution 2420+[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 s61)+Fast allSat, Looking for solution 2421+[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 s62)+Fast allSat, Looking for solution 2422+[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 s63)+Fast allSat, Looking for solution 2423+[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 s64)+Fast allSat, Looking for solution 2424+[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 s65)+Fast allSat, Looking for solution 2425+[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 s66)+Fast allSat, Looking for solution 2426+[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 s67)+Fast allSat, Looking for solution 2427+[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 s68)+Fast allSat, Looking for solution 2428+[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 s70)+Fast allSat, Looking for solution 2429+[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 s71)+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 s89)+[GOOD] (assert s83)+Fast allSat, Looking for solution 2430+[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 s70)+Fast allSat, Looking for solution 2431+[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 s71)+Fast allSat, Looking for solution 2432+[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 s68)+Fast allSat, Looking for solution 2433+[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 s67)+Fast allSat, Looking for solution 2434+[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 s66)+Fast allSat, Looking for solution 2435+[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 s65)+Fast allSat, Looking for solution 2436+[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 s64)+Fast allSat, Looking for solution 2437+[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 s63)+Fast allSat, Looking for solution 2438+[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 s62)+Fast allSat, Looking for solution 2439+[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 s60)+Fast allSat, Looking for solution 2440+[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 s58)+Fast allSat, Looking for solution 2441+[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 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 s89)+[GOOD] (assert s82)+Fast allSat, Looking for solution 2442+[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 s72)+Fast allSat, Looking for solution 2443+[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 s58)+Fast allSat, Looking for solution 2444+[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 s60)+Fast allSat, Looking for solution 2445+[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 s61)+Fast allSat, Looking for solution 2446+[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 s63)+Fast allSat, Looking for solution 2447+[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 s64)+Fast allSat, Looking for solution 2448+[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 s65)+Fast allSat, Looking for solution 2449+[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 s66)+Fast allSat, Looking for solution 2450+[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 s67)+Fast allSat, Looking for solution 2451+[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 s68)+Fast allSat, Looking for solution 2452+[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 s70)+Fast allSat, Looking for solution 2453+[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 s71)+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 s89)+[GOOD] (assert s81)+Fast allSat, Looking for solution 2454+[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 s70)+Fast allSat, Looking for solution 2455+[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 s71)+Fast allSat, Looking for solution 2456+[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 s68)+Fast allSat, Looking for solution 2457+[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 s67)+Fast allSat, Looking for solution 2458+[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 s66)+Fast allSat, Looking for solution 2459+[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 s65)+Fast allSat, Looking for solution 2460+[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 s64)+Fast allSat, Looking for solution 2461+[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 s62)+Fast allSat, Looking for solution 2462+[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 s61)+Fast allSat, Looking for solution 2463+[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 s60)+Fast allSat, Looking for solution 2464+[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 s58)+Fast allSat, Looking for solution 2465+[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 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 s89)+[GOOD] (assert s80)+Fast allSat, Looking for solution 2466+[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 s72)+Fast allSat, Looking for solution 2467+[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 s58)+Fast allSat, Looking for solution 2468+[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 s60)+Fast allSat, Looking for solution 2469+[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 s61)+Fast allSat, Looking for solution 2470+[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 s62)+Fast allSat, Looking for solution 2471+[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 s63)+Fast allSat, Looking for solution 2472+[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 s65)+Fast allSat, Looking for solution 2473+[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 s66)+Fast allSat, Looking for solution 2474+[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 s67)+Fast allSat, Looking for solution 2475+[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 s68)+Fast allSat, Looking for solution 2476+[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 s70)+Fast allSat, Looking for solution 2477+[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 s71)+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 s89)+[GOOD] (assert s79)+Fast allSat, Looking for solution 2478+[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 s70)+Fast allSat, Looking for solution 2479+[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 s71)+Fast allSat, Looking for solution 2480+[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 s68)+Fast allSat, Looking for solution 2481+[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 s67)+Fast allSat, Looking for solution 2482+[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 s66)+Fast allSat, Looking for solution 2483+[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 s64)+Fast allSat, Looking for solution 2484+[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 s63)+Fast allSat, Looking for solution 2485+[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 s62)+Fast allSat, Looking for solution 2486+[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 s61)+Fast allSat, Looking for solution 2487+[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 s60)+Fast allSat, Looking for solution 2488+[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 s58)+Fast allSat, Looking for solution 2489+[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 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 s89)+[GOOD] (assert s78)+Fast allSat, Looking for solution 2490+[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 s72)+Fast allSat, Looking for solution 2491+[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 s58)+Fast allSat, Looking for solution 2492+[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 s60)+Fast allSat, Looking for solution 2493+[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 s61)+Fast allSat, Looking for solution 2494+[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 s62)+Fast allSat, Looking for solution 2495+[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 s63)+Fast allSat, Looking for solution 2496+[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 s64)+Fast allSat, Looking for solution 2497+[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 s65)+Fast allSat, Looking for solution 2498+[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 s67)+Fast allSat, Looking for solution 2499+[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 s68)+Fast allSat, Looking for solution 2500+[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 s70)+Fast allSat, Looking for solution 2501+[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 s71)+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 s89)+[GOOD] (assert s77)+Fast allSat, Looking for solution 2502+[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 s70)+Fast allSat, Looking for solution 2503+[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 s71)+Fast allSat, Looking for solution 2504+[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 s68)+Fast allSat, Looking for solution 2505+[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 s66)+Fast allSat, Looking for solution 2506+[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 s65)+Fast allSat, Looking for solution 2507+[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 s64)+Fast allSat, Looking for solution 2508+[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 s63)+Fast allSat, Looking for solution 2509+[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 s62)+Fast allSat, Looking for solution 2510+[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 s61)+Fast allSat, Looking for solution 2511+[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 s60)+Fast allSat, Looking for solution 2512+[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 s58)+Fast allSat, Looking for solution 2513+[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 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 s89)+[GOOD] (assert s76)+Fast allSat, Looking for solution 2514+[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 s72)+Fast allSat, Looking for solution 2515+[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 s58)+Fast allSat, Looking for solution 2516+[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 s60)+Fast allSat, Looking for solution 2517+[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 s61)+Fast allSat, Looking for solution 2518+[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 s62)+Fast allSat, Looking for solution 2519+[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 s63)+Fast allSat, Looking for solution 2520+[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 s64)+Fast allSat, Looking for solution 2521+[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 s65)+Fast allSat, Looking for solution 2522+[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 s66)+Fast allSat, Looking for solution 2523+[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 5))+[GOOD] (push 1)+[GOOD] (assert s67)+Fast allSat, Looking for solution 2524+[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 s70)+Fast allSat, Looking for solution 2525+[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 s71)+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 s89)+[GOOD] (assert s74)+Fast allSat, Looking for solution 2526+[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 s71)+Fast allSat, Looking for solution 2527+[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 s68)+Fast allSat, Looking for solution 2528+[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 s67)+Fast allSat, Looking for solution 2529+[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 s66)+Fast allSat, Looking for solution 2530+[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 s65)+Fast allSat, Looking for solution 2531+[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 s64)+Fast allSat, Looking for solution 2532+[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 s63)+Fast allSat, Looking for solution 2533+[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 s62)+Fast allSat, Looking for solution 2534+[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 s61)+Fast allSat, Looking for solution 2535+[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 s60)+Fast allSat, Looking for solution 2536+[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 s58)+Fast allSat, Looking for solution 2537+[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 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 s70)+[GOOD] (assert s101)+[GOOD] (assert s73)+Fast allSat, Looking for solution 2538+[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 s72)+Fast allSat, Looking for solution 2539+[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 s58)+Fast allSat, Looking for solution 2540+[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 s60)+Fast allSat, Looking for solution 2541+[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 s61)+Fast allSat, Looking for solution 2542+[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 s62)+Fast allSat, Looking for solution 2543+[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 s63)+Fast allSat, Looking for solution 2544+[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 s64)+Fast allSat, Looking for solution 2545+[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 s65)+Fast allSat, Looking for solution 2546+[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 s66)+Fast allSat, Looking for solution 2547+[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 s67)+Fast allSat, Looking for solution 2548+[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 s68)+Fast allSat, Looking for solution 2549+[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 s89)+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 s55)+[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 15))+[GOOD] (push 1)+[GOOD] (assert s54)+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 15))+[GOOD] (push 1)+[GOOD] (assert s53)+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 15))+[GOOD] (push 1)+[GOOD] (assert s52)+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 15))+[GOOD] (push 1)+[GOOD] (assert s51)+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 15))+[GOOD] (push 1)+[GOOD] (assert s50)+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 15))+[GOOD] (push 1)+[GOOD] (assert s49)+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 15))+[GOOD] (push 1)+[GOOD] (assert s48)+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 15))+[GOOD] (push 1)+[GOOD] (assert s47)+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 15))+[GOOD] (push 1)+[GOOD] (assert s46)+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 15))+[GOOD] (push 1)+[GOOD] (assert s45)+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 15))+[GOOD] (push 1)+[GOOD] (assert s43)+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 s57)+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 s87)+Fast allSat, Looking for solution 2563+[SEND] (check-sat)+[RECV] unsat+[GOOD] (pop 1)+[GOOD] (push 1)+[GOOD] (assert s72)+[GOOD] (assert s88)+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 s58)+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 s60)+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 s61)+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 s62)+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 s63)+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 s64)+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 s65)+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 s66)+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 s67)+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 s68)+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 s69)+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 s70)+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 s89)+[GOOD] (assert s59)+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 s70)+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 s69)+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 s68)+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 s67)+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 s66)+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 s65)+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 s64)+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 s63)+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 s62)+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 s61)+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 s60)+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 s58)+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 s89)+[GOOD] (assert s85)+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 5))+[GOOD] (push 1)+[GOOD] (assert s67)+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 6))+[GOOD] (push 1)+[GOOD] (assert s66)+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 s65)+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 8))+[GOOD] (push 1)+[GOOD] (assert s64)+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 9))+[GOOD] (push 1)+[GOOD] (assert s63)+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 10))+[GOOD] (push 1)+[GOOD] (assert s62)+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 11))+[GOOD] (push 1)+[GOOD] (assert s61)+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 12))+[GOOD] (push 1)+[GOOD] (assert s60)+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 s68)+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 s69)+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 2))+[GOOD] (push 1)+[GOOD] (assert s70)+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 14))+[GOOD] (push 1)+[GOOD] (assert s72)+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 s89)+[GOOD] (assert s84)+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 7))+[GOOD] (push 1)+[GOOD] (assert s65)+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 8))+[GOOD] (push 1)+[GOOD] (assert s64)+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 s63)+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 10))+[GOOD] (push 1)+[GOOD] (assert s62)+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 11))+[GOOD] (push 1)+[GOOD] (assert s61)+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 s66)+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 s67)+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 s68)+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 s69)+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 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 13))+[GOOD] (push 1)+[GOOD] (assert s58)+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 14))+[GOOD] (push 1)+[GOOD] (assert s72)+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 s89)+[GOOD] (assert s83)+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 14))+[GOOD] (push 1)+[GOOD] (assert s72)+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 13))+[GOOD] (push 1)+[GOOD] (assert s58)+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 12))+[GOOD] (push 1)+[GOOD] (assert s60)+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 10))+[GOOD] (push 1)+[GOOD] (assert s62)+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 9))+[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 8))+[GOOD] (push 1)+[GOOD] (assert s64)+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 7))+[GOOD] (push 1)+[GOOD] (assert s65)+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 6))+[GOOD] (push 1)+[GOOD] (assert s66)+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 5))+[GOOD] (push 1)+[GOOD] (assert s67)+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 4))+[GOOD] (push 1)+[GOOD] (assert s68)+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 3))+[GOOD] (push 1)+[GOOD] (assert s69)+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 2))+[GOOD] (push 1)+[GOOD] (assert s70)+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 s89)+[GOOD] (assert s82)+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 s63)+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 s64)+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 s65)+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 s66)+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 s67)+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 s68)+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 s69)+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 2))+[GOOD] (push 1)+[GOOD] (assert s70)+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 11))+[GOOD] (push 1)+[GOOD] (assert s61)+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 12))+[GOOD] (push 1)+[GOOD] (assert s60)+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 13))+[GOOD] (push 1)+[GOOD] (assert s58)+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 14))+[GOOD] (push 1)+[GOOD] (assert s72)+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 s89)+[GOOD] (assert s81)+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 14))+[GOOD] (push 1)+[GOOD] (assert s72)+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 13))+[GOOD] (push 1)+[GOOD] (assert s58)+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 12))+[GOOD] (push 1)+[GOOD] (assert s60)+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 11))+[GOOD] (push 1)+[GOOD] (assert s61)+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 10))+[GOOD] (push 1)+[GOOD] (assert s62)+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 8))+[GOOD] (push 1)+[GOOD] (assert s64)+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 7))+[GOOD] (push 1)+[GOOD] (assert s65)+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 6))+[GOOD] (push 1)+[GOOD] (assert s66)+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 5))+[GOOD] (push 1)+[GOOD] (assert s67)+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 4))+[GOOD] (push 1)+[GOOD] (assert s68)+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 3))+[GOOD] (push 1)+[GOOD] (assert s69)+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 2))+[GOOD] (push 1)+[GOOD] (assert s70)+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 s89)+[GOOD] (assert s80)+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 s65)+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 s66)+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 s67)+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 s68)+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 s69)+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 2))+[GOOD] (push 1)+[GOOD] (assert s70)+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 9))+[GOOD] (push 1)+[GOOD] (assert s63)+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 10))+[GOOD] (push 1)+[GOOD] (assert s62)+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 11))+[GOOD] (push 1)+[GOOD] (assert s61)+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 12))+[GOOD] (push 1)+[GOOD] (assert s60)+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 13))+[GOOD] (push 1)+[GOOD] (assert s58)+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 14))+[GOOD] (push 1)+[GOOD] (assert s72)+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 s89)+[GOOD] (assert s79)+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 14))+[GOOD] (push 1)+[GOOD] (assert s72)+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 13))+[GOOD] (push 1)+[GOOD] (assert s58)+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 12))+[GOOD] (push 1)+[GOOD] (assert s60)+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 11))+[GOOD] (push 1)+[GOOD] (assert s61)+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 10))+[GOOD] (push 1)+[GOOD] (assert s62)+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 s63)+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 8))+[GOOD] (push 1)+[GOOD] (assert s64)+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 6))+[GOOD] (push 1)+[GOOD] (assert s66)+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 5))+[GOOD] (push 1)+[GOOD] (assert s67)+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 4))+[GOOD] (push 1)+[GOOD] (assert s68)+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 3))+[GOOD] (push 1)+[GOOD] (assert s69)+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 2))+[GOOD] (push 1)+[GOOD] (assert s70)+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 s89)+[GOOD] (assert s78)+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 s67)+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 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 3))+[GOOD] (push 1)+[GOOD] (assert s69)+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 2))+[GOOD] (push 1)+[GOOD] (assert s70)+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 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 8))+[GOOD] (push 1)+[GOOD] (assert s64)+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 9))+[GOOD] (push 1)+[GOOD] (assert s63)+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 10))+[GOOD] (push 1)+[GOOD] (assert s62)+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 11))+[GOOD] (push 1)+[GOOD] (assert s61)+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 12))+[GOOD] (push 1)+[GOOD] (assert s60)+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 13))+[GOOD] (push 1)+[GOOD] (assert s58)+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 14))+[GOOD] (push 1)+[GOOD] (assert s72)+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 s89)+[GOOD] (assert s77)+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 14))+[GOOD] (push 1)+[GOOD] (assert s72)+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 13))+[GOOD] (push 1)+[GOOD] (assert s58)+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 12))+[GOOD] (push 1)+[GOOD] (assert s60)+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 11))+[GOOD] (push 1)+[GOOD] (assert s61)+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 10))+[GOOD] (push 1)+[GOOD] (assert s62)+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 s63)+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 8))+[GOOD] (push 1)+[GOOD] (assert s64)+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 7))+[GOOD] (push 1)+[GOOD] (assert s65)+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 6))+[GOOD] (push 1)+[GOOD] (assert s66)+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 4))+[GOOD] (push 1)+[GOOD] (assert s68)+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 3))+[GOOD] (push 1)+[GOOD] (assert s69)+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 2))+[GOOD] (push 1)+[GOOD] (assert s70)+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 s89)+[GOOD] (assert s76)+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 s69)+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 2))+[GOOD] (push 1)+[GOOD] (assert s70)+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 5))+[GOOD] (push 1)+[GOOD] (assert s67)+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 6))+[GOOD] (push 1)+[GOOD] (assert s66)+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 7))+[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 8))+[GOOD] (push 1)+[GOOD] (assert s64)+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 9))+[GOOD] (push 1)+[GOOD] (assert s63)+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 10))+[GOOD] (push 1)+[GOOD] (assert s62)+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 11))+[GOOD] (push 1)+[GOOD] (assert s61)+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 12))+[GOOD] (push 1)+[GOOD] (assert s60)+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 13))+[GOOD] (push 1)+[GOOD] (assert s58)+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 14))+[GOOD] (push 1)+[GOOD] (assert s72)+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 s89)+[GOOD] (assert s75)+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 s70)+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 4))+[GOOD] (push 1)+[GOOD] (assert s68)+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 5))+[GOOD] (push 1)+[GOOD] (assert s67)+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 6))+[GOOD] (push 1)+[GOOD] (assert s66)+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 7))+[GOOD] (push 1)+[GOOD] (assert s65)+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 8))+[GOOD] (push 1)+[GOOD] (assert s64)+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 9))+[GOOD] (push 1)+[GOOD] (assert s63)+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 10))+[GOOD] (push 1)+[GOOD] (assert s62)+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 11))+[GOOD] (push 1)+[GOOD] (assert s61)+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 12))+[GOOD] (push 1)+[GOOD] (assert s60)+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 13))+[GOOD] (push 1)+[GOOD] (assert s58)+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 14))+[GOOD] (push 1)+[GOOD] (assert s72)+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 s69)+[GOOD] (assert s102)+[GOOD] (assert s74) Fast allSat, Looking for solution 2719 [SEND] (check-sat) [RECV] sat
SBVTestSuite/GoldFiles/allSat8.gold view
@@ -44,7 +44,7 @@ *** allSat: Unsupported: Building a rejecting instance for: *** ***     f :: SInteger -> SInteger-***     f x = 1 + x+***     f x = x + 1 *** *** At this time, SBV cannot compute allSat when the model has a non-table definition. ***@@ -61,4 +61,4 @@ *** NB. If this is a use case you'd like SBV to support, please get in touch!  CallStack (from HasCallStack):-  error, called at ./Data/SBV/Control/Utils.hs:1469:57 in sbv-10.2-inplace:Data.SBV.Control.Utils+  error, called at ./Data/SBV/Control/Utils.hs:1634:57 in sbv-10.3-inplace:Data.SBV.Control.Utils
SBVTestSuite/GoldFiles/auf-1.gold view
@@ -12,7 +12,7 @@   array_1 :: SWord32 -> SWord32      Context:  cloned from array_0 with s0 :: SWord32 |-> s5 :: SWord32 UNINTERPRETED CONSTANTS-  [uninterpreted] f :: (Nothing,SWord32 -> SWord64)+  [uninterpreted] f :: (True,Nothing,SWord32 -> SWord64) USER GIVEN CODE SEGMENTS AXIOMS-DEFINITIONS DEFINE
SBVTestSuite/GoldFiles/charConstr01.gold view
@@ -39,6 +39,6 @@ [SEND] (get-value (cf)) [RECV] ((cf ((as const (Array Int String)) "B"))) -MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [], modelUIFuns = [("cf",(SInteger -> SChar,Right ([],'B' :: Char)))]}+MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [], modelUIFuns = [("cf",(True,SInteger -> SChar,Right ([],'B' :: Char)))]} DONE.*** Solver   : Z3 *** Exit code: ExitSuccess
SBVTestSuite/GoldFiles/charConstr02.gold view
@@ -50,6 +50,6 @@ [RECV] ((cf3 ((as const (Array Int (SBVTuple3 String String String)))          (mkSBVTuple3 "A" "A" "A")))) -MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [], modelUIFuns = [("cf3",(SInteger -> (SChar, SChar, SChar),Right ([],('A','A','A') :: (Char, Char, Char))))]}+MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [], modelUIFuns = [("cf3",(True,SInteger -> (SChar, SChar, SChar),Right ([],('A','A','A') :: (Char, Char, Char))))]} DONE.*** Solver   : Z3 *** Exit code: ExitSuccess
SBVTestSuite/GoldFiles/charConstr08.gold view
@@ -36,8 +36,7 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (s0))-[RECV] ((s0 (lambda ((x!1 String))-         (and (not (and (not (= x!1 "A")) (not (= x!1 "B")))) (not (= x!1 "B"))))))+[RECV] ((s0 (lambda ((x!1 String)) (= x!1 "A"))))  MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [("x",{'A'} :: {Char})], modelUIFuns = []} DONE.*** Solver   : Z3
SBVTestSuite/GoldFiles/charConstr11.gold view
@@ -54,6 +54,6 @@             (Array Int String (Seq (SBVTuple2 (SBVTuple2 String String) (Seq Int)))))          (seq.unit (mkSBVTuple2 (mkSBVTuple2 "A" "A") (seq.unit 2)))))) -MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [("x",3 :: Integer),("c",'A' :: Char)], modelUIFuns = [("cf4",(SInteger -> SChar -> [((SChar, SChar), [SInteger])],Right ([],[(('A','A'),[2])] :: [((Char, Char), [Integer])])))]}+MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [("x",3 :: Integer),("c",'A' :: Char)], modelUIFuns = [("cf4",(True,SInteger -> SChar -> [((SChar, SChar), [SInteger])],Right ([],[(('A','A'),[2])] :: [((Char, Char), [Integer])])))]} DONE.*** Solver   : Z3 *** Exit code: ExitSuccess
− SBVTestSuite/GoldFiles/crcPolyExist.gold 
@@ -1,3478 +0,0 @@-INPUTS-  s0 :: SWord16, aliasing "poly"-CONSTANTS-TABLES-ARRAYS-UNINTERPRETED CONSTANTS-USER GIVEN CODE SEGMENTS-AXIOMS-DEFINITIONS-DEFINE-  s1 :: SBool = [quantified boolean] (forall ((l1_s0 (_ BitVec 48)) (l1_s1 (_ BitVec 48)))-  (let ((l1_s3 #b0))-  (let ((l1_s11 #x01))-  (let ((l1_s3333 #x00))-  (let ((l1_s3461 #x04))-  (let ((l1_s2 ((_ extract 0 0) s0)))-  (let ((l1_s4 (distinct l1_s2 l1_s3)))-  (let ((l1_s5 (distinct l1_s0 l1_s1)))-  (let ((l1_s6 ((_ extract 47 47) l1_s0)))-  (let ((l1_s7 (distinct l1_s3 l1_s6)))-  (let ((l1_s8 ((_ extract 47 47) l1_s1)))-  (let ((l1_s9 (distinct l1_s3 l1_s8)))-  (let ((l1_s10 (xor l1_s7 l1_s9)))-  (let ((l1_s12 ((_ extract 46 46) l1_s0)))-  (let ((l1_s13 (distinct l1_s3 l1_s12)))-  (let ((l1_s14 ((_ extract 46 46) l1_s1)))-  (let ((l1_s15 (distinct l1_s3 l1_s14)))-  (let ((l1_s16 (xor l1_s13 l1_s15)))-  (let ((l1_s17 ((_ extract 45 45) l1_s0)))-  (let ((l1_s18 (distinct l1_s3 l1_s17)))-  (let ((l1_s19 ((_ extract 45 45) l1_s1)))-  (let ((l1_s20 (distinct l1_s3 l1_s19)))-  (let ((l1_s21 (xor l1_s18 l1_s20)))-  (let ((l1_s22 ((_ extract 44 44) l1_s0)))-  (let ((l1_s23 (distinct l1_s3 l1_s22)))-  (let ((l1_s24 ((_ extract 44 44) l1_s1)))-  (let ((l1_s25 (distinct l1_s3 l1_s24)))-  (let ((l1_s26 (xor l1_s23 l1_s25)))-  (let ((l1_s27 ((_ extract 43 43) l1_s0)))-  (let ((l1_s28 (distinct l1_s3 l1_s27)))-  (let ((l1_s29 ((_ extract 43 43) l1_s1)))-  (let ((l1_s30 (distinct l1_s3 l1_s29)))-  (let ((l1_s31 (xor l1_s28 l1_s30)))-  (let ((l1_s32 ((_ extract 42 42) l1_s0)))-  (let ((l1_s33 (distinct l1_s3 l1_s32)))-  (let ((l1_s34 ((_ extract 42 42) l1_s1)))-  (let ((l1_s35 (distinct l1_s3 l1_s34)))-  (let ((l1_s36 (xor l1_s33 l1_s35)))-  (let ((l1_s37 ((_ extract 41 41) l1_s0)))-  (let ((l1_s38 (distinct l1_s3 l1_s37)))-  (let ((l1_s39 ((_ extract 41 41) l1_s1)))-  (let ((l1_s40 (distinct l1_s3 l1_s39)))-  (let ((l1_s41 (xor l1_s38 l1_s40)))-  (let ((l1_s42 ((_ extract 40 40) l1_s0)))-  (let ((l1_s43 (distinct l1_s3 l1_s42)))-  (let ((l1_s44 ((_ extract 40 40) l1_s1)))-  (let ((l1_s45 (distinct l1_s3 l1_s44)))-  (let ((l1_s46 (xor l1_s43 l1_s45)))-  (let ((l1_s47 ((_ extract 39 39) l1_s0)))-  (let ((l1_s48 (distinct l1_s3 l1_s47)))-  (let ((l1_s49 ((_ extract 39 39) l1_s1)))-  (let ((l1_s50 (distinct l1_s3 l1_s49)))-  (let ((l1_s51 (xor l1_s48 l1_s50)))-  (let ((l1_s52 ((_ extract 38 38) l1_s0)))-  (let ((l1_s53 (distinct l1_s3 l1_s52)))-  (let ((l1_s54 ((_ extract 38 38) l1_s1)))-  (let ((l1_s55 (distinct l1_s3 l1_s54)))-  (let ((l1_s56 (xor l1_s53 l1_s55)))-  (let ((l1_s57 ((_ extract 37 37) l1_s0)))-  (let ((l1_s58 (distinct l1_s3 l1_s57)))-  (let ((l1_s59 ((_ extract 37 37) l1_s1)))-  (let ((l1_s60 (distinct l1_s3 l1_s59)))-  (let ((l1_s61 (xor l1_s58 l1_s60)))-  (let ((l1_s62 ((_ extract 36 36) l1_s0)))-  (let ((l1_s63 (distinct l1_s3 l1_s62)))-  (let ((l1_s64 ((_ extract 36 36) l1_s1)))-  (let ((l1_s65 (distinct l1_s3 l1_s64)))-  (let ((l1_s66 (xor l1_s63 l1_s65)))-  (let ((l1_s67 ((_ extract 35 35) l1_s0)))-  (let ((l1_s68 (distinct l1_s3 l1_s67)))-  (let ((l1_s69 ((_ extract 35 35) l1_s1)))-  (let ((l1_s70 (distinct l1_s3 l1_s69)))-  (let ((l1_s71 (xor l1_s68 l1_s70)))-  (let ((l1_s72 ((_ extract 34 34) l1_s0)))-  (let ((l1_s73 (distinct l1_s3 l1_s72)))-  (let ((l1_s74 ((_ extract 34 34) l1_s1)))-  (let ((l1_s75 (distinct l1_s3 l1_s74)))-  (let ((l1_s76 (xor l1_s73 l1_s75)))-  (let ((l1_s77 ((_ extract 33 33) l1_s0)))-  (let ((l1_s78 (distinct l1_s3 l1_s77)))-  (let ((l1_s79 ((_ extract 33 33) l1_s1)))-  (let ((l1_s80 (distinct l1_s3 l1_s79)))-  (let ((l1_s81 (xor l1_s78 l1_s80)))-  (let ((l1_s82 ((_ extract 32 32) l1_s0)))-  (let ((l1_s83 (distinct l1_s3 l1_s82)))-  (let ((l1_s84 ((_ extract 32 32) l1_s1)))-  (let ((l1_s85 (distinct l1_s3 l1_s84)))-  (let ((l1_s86 (xor l1_s83 l1_s85)))-  (let ((l1_s87 ((_ extract 31 31) l1_s0)))-  (let ((l1_s88 (distinct l1_s3 l1_s87)))-  (let ((l1_s89 ((_ extract 31 31) l1_s1)))-  (let ((l1_s90 (distinct l1_s3 l1_s89)))-  (let ((l1_s91 (xor l1_s88 l1_s90)))-  (let ((l1_s92 ((_ extract 30 30) l1_s0)))-  (let ((l1_s93 (distinct l1_s3 l1_s92)))-  (let ((l1_s94 ((_ extract 30 30) l1_s1)))-  (let ((l1_s95 (distinct l1_s3 l1_s94)))-  (let ((l1_s96 (xor l1_s93 l1_s95)))-  (let ((l1_s97 ((_ extract 29 29) l1_s0)))-  (let ((l1_s98 (distinct l1_s3 l1_s97)))-  (let ((l1_s99 ((_ extract 29 29) l1_s1)))-  (let ((l1_s100 (distinct l1_s3 l1_s99)))-  (let ((l1_s101 (xor l1_s98 l1_s100)))-  (let ((l1_s102 ((_ extract 28 28) l1_s0)))-  (let ((l1_s103 (distinct l1_s3 l1_s102)))-  (let ((l1_s104 ((_ extract 28 28) l1_s1)))-  (let ((l1_s105 (distinct l1_s3 l1_s104)))-  (let ((l1_s106 (xor l1_s103 l1_s105)))-  (let ((l1_s107 ((_ extract 27 27) l1_s0)))-  (let ((l1_s108 (distinct l1_s3 l1_s107)))-  (let ((l1_s109 ((_ extract 27 27) l1_s1)))-  (let ((l1_s110 (distinct l1_s3 l1_s109)))-  (let ((l1_s111 (xor l1_s108 l1_s110)))-  (let ((l1_s112 ((_ extract 26 26) l1_s0)))-  (let ((l1_s113 (distinct l1_s3 l1_s112)))-  (let ((l1_s114 ((_ extract 26 26) l1_s1)))-  (let ((l1_s115 (distinct l1_s3 l1_s114)))-  (let ((l1_s116 (xor l1_s113 l1_s115)))-  (let ((l1_s117 ((_ extract 25 25) l1_s0)))-  (let ((l1_s118 (distinct l1_s3 l1_s117)))-  (let ((l1_s119 ((_ extract 25 25) l1_s1)))-  (let ((l1_s120 (distinct l1_s3 l1_s119)))-  (let ((l1_s121 (xor l1_s118 l1_s120)))-  (let ((l1_s122 ((_ extract 24 24) l1_s0)))-  (let ((l1_s123 (distinct l1_s3 l1_s122)))-  (let ((l1_s124 ((_ extract 24 24) l1_s1)))-  (let ((l1_s125 (distinct l1_s3 l1_s124)))-  (let ((l1_s126 (xor l1_s123 l1_s125)))-  (let ((l1_s127 ((_ extract 23 23) l1_s0)))-  (let ((l1_s128 (distinct l1_s3 l1_s127)))-  (let ((l1_s129 ((_ extract 23 23) l1_s1)))-  (let ((l1_s130 (distinct l1_s3 l1_s129)))-  (let ((l1_s131 (xor l1_s128 l1_s130)))-  (let ((l1_s132 ((_ extract 22 22) l1_s0)))-  (let ((l1_s133 (distinct l1_s3 l1_s132)))-  (let ((l1_s134 ((_ extract 22 22) l1_s1)))-  (let ((l1_s135 (distinct l1_s3 l1_s134)))-  (let ((l1_s136 (xor l1_s133 l1_s135)))-  (let ((l1_s137 ((_ extract 21 21) l1_s0)))-  (let ((l1_s138 (distinct l1_s3 l1_s137)))-  (let ((l1_s139 ((_ extract 21 21) l1_s1)))-  (let ((l1_s140 (distinct l1_s3 l1_s139)))-  (let ((l1_s141 (xor l1_s138 l1_s140)))-  (let ((l1_s142 ((_ extract 20 20) l1_s0)))-  (let ((l1_s143 (distinct l1_s3 l1_s142)))-  (let ((l1_s144 ((_ extract 20 20) l1_s1)))-  (let ((l1_s145 (distinct l1_s3 l1_s144)))-  (let ((l1_s146 (xor l1_s143 l1_s145)))-  (let ((l1_s147 ((_ extract 19 19) l1_s0)))-  (let ((l1_s148 (distinct l1_s3 l1_s147)))-  (let ((l1_s149 ((_ extract 19 19) l1_s1)))-  (let ((l1_s150 (distinct l1_s3 l1_s149)))-  (let ((l1_s151 (xor l1_s148 l1_s150)))-  (let ((l1_s152 ((_ extract 18 18) l1_s0)))-  (let ((l1_s153 (distinct l1_s3 l1_s152)))-  (let ((l1_s154 ((_ extract 18 18) l1_s1)))-  (let ((l1_s155 (distinct l1_s3 l1_s154)))-  (let ((l1_s156 (xor l1_s153 l1_s155)))-  (let ((l1_s157 ((_ extract 17 17) l1_s0)))-  (let ((l1_s158 (distinct l1_s3 l1_s157)))-  (let ((l1_s159 ((_ extract 17 17) l1_s1)))-  (let ((l1_s160 (distinct l1_s3 l1_s159)))-  (let ((l1_s161 (xor l1_s158 l1_s160)))-  (let ((l1_s162 ((_ extract 16 16) l1_s0)))-  (let ((l1_s163 (distinct l1_s3 l1_s162)))-  (let ((l1_s164 ((_ extract 16 16) l1_s1)))-  (let ((l1_s165 (distinct l1_s3 l1_s164)))-  (let ((l1_s166 (xor l1_s163 l1_s165)))-  (let ((l1_s167 ((_ extract 15 15) l1_s0)))-  (let ((l1_s168 (distinct l1_s3 l1_s167)))-  (let ((l1_s169 ((_ extract 15 15) l1_s1)))-  (let ((l1_s170 (distinct l1_s3 l1_s169)))-  (let ((l1_s171 (xor l1_s168 l1_s170)))-  (let ((l1_s172 ((_ extract 14 14) l1_s0)))-  (let ((l1_s173 (distinct l1_s3 l1_s172)))-  (let ((l1_s174 ((_ extract 14 14) l1_s1)))-  (let ((l1_s175 (distinct l1_s3 l1_s174)))-  (let ((l1_s176 (xor l1_s173 l1_s175)))-  (let ((l1_s177 ((_ extract 13 13) l1_s0)))-  (let ((l1_s178 (distinct l1_s3 l1_s177)))-  (let ((l1_s179 ((_ extract 13 13) l1_s1)))-  (let ((l1_s180 (distinct l1_s3 l1_s179)))-  (let ((l1_s181 (xor l1_s178 l1_s180)))-  (let ((l1_s182 ((_ extract 12 12) l1_s0)))-  (let ((l1_s183 (distinct l1_s3 l1_s182)))-  (let ((l1_s184 ((_ extract 12 12) l1_s1)))-  (let ((l1_s185 (distinct l1_s3 l1_s184)))-  (let ((l1_s186 (xor l1_s183 l1_s185)))-  (let ((l1_s187 ((_ extract 11 11) l1_s0)))-  (let ((l1_s188 (distinct l1_s3 l1_s187)))-  (let ((l1_s189 ((_ extract 11 11) l1_s1)))-  (let ((l1_s190 (distinct l1_s3 l1_s189)))-  (let ((l1_s191 (xor l1_s188 l1_s190)))-  (let ((l1_s192 ((_ extract 10 10) l1_s0)))-  (let ((l1_s193 (distinct l1_s3 l1_s192)))-  (let ((l1_s194 ((_ extract 10 10) l1_s1)))-  (let ((l1_s195 (distinct l1_s3 l1_s194)))-  (let ((l1_s196 (xor l1_s193 l1_s195)))-  (let ((l1_s197 ((_ extract 9 9) l1_s0)))-  (let ((l1_s198 (distinct l1_s3 l1_s197)))-  (let ((l1_s199 ((_ extract 9 9) l1_s1)))-  (let ((l1_s200 (distinct l1_s3 l1_s199)))-  (let ((l1_s201 (xor l1_s198 l1_s200)))-  (let ((l1_s202 ((_ extract 8 8) l1_s0)))-  (let ((l1_s203 (distinct l1_s3 l1_s202)))-  (let ((l1_s204 ((_ extract 8 8) l1_s1)))-  (let ((l1_s205 (distinct l1_s3 l1_s204)))-  (let ((l1_s206 (xor l1_s203 l1_s205)))-  (let ((l1_s207 ((_ extract 7 7) l1_s0)))-  (let ((l1_s208 (distinct l1_s3 l1_s207)))-  (let ((l1_s209 ((_ extract 7 7) l1_s1)))-  (let ((l1_s210 (distinct l1_s3 l1_s209)))-  (let ((l1_s211 (xor l1_s208 l1_s210)))-  (let ((l1_s212 ((_ extract 6 6) l1_s0)))-  (let ((l1_s213 (distinct l1_s3 l1_s212)))-  (let ((l1_s214 ((_ extract 6 6) l1_s1)))-  (let ((l1_s215 (distinct l1_s3 l1_s214)))-  (let ((l1_s216 (xor l1_s213 l1_s215)))-  (let ((l1_s217 ((_ extract 5 5) l1_s0)))-  (let ((l1_s218 (distinct l1_s3 l1_s217)))-  (let ((l1_s219 ((_ extract 5 5) l1_s1)))-  (let ((l1_s220 (distinct l1_s3 l1_s219)))-  (let ((l1_s221 (xor l1_s218 l1_s220)))-  (let ((l1_s222 ((_ extract 4 4) l1_s0)))-  (let ((l1_s223 (distinct l1_s3 l1_s222)))-  (let ((l1_s224 ((_ extract 4 4) l1_s1)))-  (let ((l1_s225 (distinct l1_s3 l1_s224)))-  (let ((l1_s226 (xor l1_s223 l1_s225)))-  (let ((l1_s227 ((_ extract 3 3) l1_s0)))-  (let ((l1_s228 (distinct l1_s3 l1_s227)))-  (let ((l1_s229 ((_ extract 3 3) l1_s1)))-  (let ((l1_s230 (distinct l1_s3 l1_s229)))-  (let ((l1_s231 (xor l1_s228 l1_s230)))-  (let ((l1_s232 ((_ extract 2 2) l1_s0)))-  (let ((l1_s233 (distinct l1_s3 l1_s232)))-  (let ((l1_s234 ((_ extract 2 2) l1_s1)))-  (let ((l1_s235 (distinct l1_s3 l1_s234)))-  (let ((l1_s236 (xor l1_s233 l1_s235)))-  (let ((l1_s237 ((_ extract 1 1) l1_s0)))-  (let ((l1_s238 (distinct l1_s3 l1_s237)))-  (let ((l1_s239 ((_ extract 1 1) l1_s1)))-  (let ((l1_s240 (distinct l1_s3 l1_s239)))-  (let ((l1_s241 (xor l1_s238 l1_s240)))-  (let ((l1_s242 ((_ extract 0 0) l1_s0)))-  (let ((l1_s243 (distinct l1_s3 l1_s242)))-  (let ((l1_s244 ((_ extract 0 0) l1_s1)))-  (let ((l1_s245 (distinct l1_s3 l1_s244)))-  (let ((l1_s246 (xor l1_s243 l1_s245)))-  (let ((l1_s247 ((_ extract 15 15) s0)))-  (let ((l1_s248 (distinct l1_s3 l1_s247)))-  (let ((l1_s249 (xor l1_s13 l1_s248)))-  (let ((l1_s250 (ite l1_s7 l1_s249 l1_s13)))-  (let ((l1_s251 ((_ extract 14 14) s0)))-  (let ((l1_s252 (distinct l1_s3 l1_s251)))-  (let ((l1_s253 (xor l1_s18 l1_s252)))-  (let ((l1_s254 (ite l1_s7 l1_s253 l1_s18)))-  (let ((l1_s255 (xor l1_s248 l1_s254)))-  (let ((l1_s256 (ite l1_s250 l1_s255 l1_s254)))-  (let ((l1_s257 ((_ extract 13 13) s0)))-  (let ((l1_s258 (distinct l1_s3 l1_s257)))-  (let ((l1_s259 (xor l1_s23 l1_s258)))-  (let ((l1_s260 (ite l1_s7 l1_s259 l1_s23)))-  (let ((l1_s261 (xor l1_s252 l1_s260)))-  (let ((l1_s262 (ite l1_s250 l1_s261 l1_s260)))-  (let ((l1_s263 (xor l1_s248 l1_s262)))-  (let ((l1_s264 (ite l1_s256 l1_s263 l1_s262)))-  (let ((l1_s265 ((_ extract 12 12) s0)))-  (let ((l1_s266 (distinct l1_s3 l1_s265)))-  (let ((l1_s267 (xor l1_s28 l1_s266)))-  (let ((l1_s268 (ite l1_s7 l1_s267 l1_s28)))-  (let ((l1_s269 (xor l1_s258 l1_s268)))-  (let ((l1_s270 (ite l1_s250 l1_s269 l1_s268)))-  (let ((l1_s271 (xor l1_s252 l1_s270)))-  (let ((l1_s272 (ite l1_s256 l1_s271 l1_s270)))-  (let ((l1_s273 (xor l1_s248 l1_s272)))-  (let ((l1_s274 (ite l1_s264 l1_s273 l1_s272)))-  (let ((l1_s275 ((_ extract 11 11) s0)))-  (let ((l1_s276 (distinct l1_s3 l1_s275)))-  (let ((l1_s277 (xor l1_s33 l1_s276)))-  (let ((l1_s278 (ite l1_s7 l1_s277 l1_s33)))-  (let ((l1_s279 (xor l1_s266 l1_s278)))-  (let ((l1_s280 (ite l1_s250 l1_s279 l1_s278)))-  (let ((l1_s281 (xor l1_s258 l1_s280)))-  (let ((l1_s282 (ite l1_s256 l1_s281 l1_s280)))-  (let ((l1_s283 (xor l1_s252 l1_s282)))-  (let ((l1_s284 (ite l1_s264 l1_s283 l1_s282)))-  (let ((l1_s285 (xor l1_s248 l1_s284)))-  (let ((l1_s286 (ite l1_s274 l1_s285 l1_s284)))-  (let ((l1_s287 ((_ extract 10 10) s0)))-  (let ((l1_s288 (distinct l1_s3 l1_s287)))-  (let ((l1_s289 (xor l1_s38 l1_s288)))-  (let ((l1_s290 (ite l1_s7 l1_s289 l1_s38)))-  (let ((l1_s291 (xor l1_s276 l1_s290)))-  (let ((l1_s292 (ite l1_s250 l1_s291 l1_s290)))-  (let ((l1_s293 (xor l1_s266 l1_s292)))-  (let ((l1_s294 (ite l1_s256 l1_s293 l1_s292)))-  (let ((l1_s295 (xor l1_s258 l1_s294)))-  (let ((l1_s296 (ite l1_s264 l1_s295 l1_s294)))-  (let ((l1_s297 (xor l1_s252 l1_s296)))-  (let ((l1_s298 (ite l1_s274 l1_s297 l1_s296)))-  (let ((l1_s299 (xor l1_s248 l1_s298)))-  (let ((l1_s300 (ite l1_s286 l1_s299 l1_s298)))-  (let ((l1_s301 ((_ extract 9 9) s0)))-  (let ((l1_s302 (distinct l1_s3 l1_s301)))-  (let ((l1_s303 (xor l1_s43 l1_s302)))-  (let ((l1_s304 (ite l1_s7 l1_s303 l1_s43)))-  (let ((l1_s305 (xor l1_s288 l1_s304)))-  (let ((l1_s306 (ite l1_s250 l1_s305 l1_s304)))-  (let ((l1_s307 (xor l1_s276 l1_s306)))-  (let ((l1_s308 (ite l1_s256 l1_s307 l1_s306)))-  (let ((l1_s309 (xor l1_s266 l1_s308)))-  (let ((l1_s310 (ite l1_s264 l1_s309 l1_s308)))-  (let ((l1_s311 (xor l1_s258 l1_s310)))-  (let ((l1_s312 (ite l1_s274 l1_s311 l1_s310)))-  (let ((l1_s313 (xor l1_s252 l1_s312)))-  (let ((l1_s314 (ite l1_s286 l1_s313 l1_s312)))-  (let ((l1_s315 (xor l1_s248 l1_s314)))-  (let ((l1_s316 (ite l1_s300 l1_s315 l1_s314)))-  (let ((l1_s317 ((_ extract 8 8) s0)))-  (let ((l1_s318 (distinct l1_s3 l1_s317)))-  (let ((l1_s319 (xor l1_s48 l1_s318)))-  (let ((l1_s320 (ite l1_s7 l1_s319 l1_s48)))-  (let ((l1_s321 (xor l1_s302 l1_s320)))-  (let ((l1_s322 (ite l1_s250 l1_s321 l1_s320)))-  (let ((l1_s323 (xor l1_s288 l1_s322)))-  (let ((l1_s324 (ite l1_s256 l1_s323 l1_s322)))-  (let ((l1_s325 (xor l1_s276 l1_s324)))-  (let ((l1_s326 (ite l1_s264 l1_s325 l1_s324)))-  (let ((l1_s327 (xor l1_s266 l1_s326)))-  (let ((l1_s328 (ite l1_s274 l1_s327 l1_s326)))-  (let ((l1_s329 (xor l1_s258 l1_s328)))-  (let ((l1_s330 (ite l1_s286 l1_s329 l1_s328)))-  (let ((l1_s331 (xor l1_s252 l1_s330)))-  (let ((l1_s332 (ite l1_s300 l1_s331 l1_s330)))-  (let ((l1_s333 (xor l1_s248 l1_s332)))-  (let ((l1_s334 (ite l1_s316 l1_s333 l1_s332)))-  (let ((l1_s335 ((_ extract 7 7) s0)))-  (let ((l1_s336 (distinct l1_s3 l1_s335)))-  (let ((l1_s337 (xor l1_s53 l1_s336)))-  (let ((l1_s338 (ite l1_s7 l1_s337 l1_s53)))-  (let ((l1_s339 (xor l1_s318 l1_s338)))-  (let ((l1_s340 (ite l1_s250 l1_s339 l1_s338)))-  (let ((l1_s341 (xor l1_s302 l1_s340)))-  (let ((l1_s342 (ite l1_s256 l1_s341 l1_s340)))-  (let ((l1_s343 (xor l1_s288 l1_s342)))-  (let ((l1_s344 (ite l1_s264 l1_s343 l1_s342)))-  (let ((l1_s345 (xor l1_s276 l1_s344)))-  (let ((l1_s346 (ite l1_s274 l1_s345 l1_s344)))-  (let ((l1_s347 (xor l1_s266 l1_s346)))-  (let ((l1_s348 (ite l1_s286 l1_s347 l1_s346)))-  (let ((l1_s349 (xor l1_s258 l1_s348)))-  (let ((l1_s350 (ite l1_s300 l1_s349 l1_s348)))-  (let ((l1_s351 (xor l1_s252 l1_s350)))-  (let ((l1_s352 (ite l1_s316 l1_s351 l1_s350)))-  (let ((l1_s353 (xor l1_s248 l1_s352)))-  (let ((l1_s354 (ite l1_s334 l1_s353 l1_s352)))-  (let ((l1_s355 ((_ extract 6 6) s0)))-  (let ((l1_s356 (distinct l1_s3 l1_s355)))-  (let ((l1_s357 (xor l1_s58 l1_s356)))-  (let ((l1_s358 (ite l1_s7 l1_s357 l1_s58)))-  (let ((l1_s359 (xor l1_s336 l1_s358)))-  (let ((l1_s360 (ite l1_s250 l1_s359 l1_s358)))-  (let ((l1_s361 (xor l1_s318 l1_s360)))-  (let ((l1_s362 (ite l1_s256 l1_s361 l1_s360)))-  (let ((l1_s363 (xor l1_s302 l1_s362)))-  (let ((l1_s364 (ite l1_s264 l1_s363 l1_s362)))-  (let ((l1_s365 (xor l1_s288 l1_s364)))-  (let ((l1_s366 (ite l1_s274 l1_s365 l1_s364)))-  (let ((l1_s367 (xor l1_s276 l1_s366)))-  (let ((l1_s368 (ite l1_s286 l1_s367 l1_s366)))-  (let ((l1_s369 (xor l1_s266 l1_s368)))-  (let ((l1_s370 (ite l1_s300 l1_s369 l1_s368)))-  (let ((l1_s371 (xor l1_s258 l1_s370)))-  (let ((l1_s372 (ite l1_s316 l1_s371 l1_s370)))-  (let ((l1_s373 (xor l1_s252 l1_s372)))-  (let ((l1_s374 (ite l1_s334 l1_s373 l1_s372)))-  (let ((l1_s375 (xor l1_s248 l1_s374)))-  (let ((l1_s376 (ite l1_s354 l1_s375 l1_s374)))-  (let ((l1_s377 ((_ extract 5 5) s0)))-  (let ((l1_s378 (distinct l1_s3 l1_s377)))-  (let ((l1_s379 (xor l1_s63 l1_s378)))-  (let ((l1_s380 (ite l1_s7 l1_s379 l1_s63)))-  (let ((l1_s381 (xor l1_s356 l1_s380)))-  (let ((l1_s382 (ite l1_s250 l1_s381 l1_s380)))-  (let ((l1_s383 (xor l1_s336 l1_s382)))-  (let ((l1_s384 (ite l1_s256 l1_s383 l1_s382)))-  (let ((l1_s385 (xor l1_s318 l1_s384)))-  (let ((l1_s386 (ite l1_s264 l1_s385 l1_s384)))-  (let ((l1_s387 (xor l1_s302 l1_s386)))-  (let ((l1_s388 (ite l1_s274 l1_s387 l1_s386)))-  (let ((l1_s389 (xor l1_s288 l1_s388)))-  (let ((l1_s390 (ite l1_s286 l1_s389 l1_s388)))-  (let ((l1_s391 (xor l1_s276 l1_s390)))-  (let ((l1_s392 (ite l1_s300 l1_s391 l1_s390)))-  (let ((l1_s393 (xor l1_s266 l1_s392)))-  (let ((l1_s394 (ite l1_s316 l1_s393 l1_s392)))-  (let ((l1_s395 (xor l1_s258 l1_s394)))-  (let ((l1_s396 (ite l1_s334 l1_s395 l1_s394)))-  (let ((l1_s397 (xor l1_s252 l1_s396)))-  (let ((l1_s398 (ite l1_s354 l1_s397 l1_s396)))-  (let ((l1_s399 (xor l1_s248 l1_s398)))-  (let ((l1_s400 (ite l1_s376 l1_s399 l1_s398)))-  (let ((l1_s401 ((_ extract 4 4) s0)))-  (let ((l1_s402 (distinct l1_s3 l1_s401)))-  (let ((l1_s403 (xor l1_s68 l1_s402)))-  (let ((l1_s404 (ite l1_s7 l1_s403 l1_s68)))-  (let ((l1_s405 (xor l1_s378 l1_s404)))-  (let ((l1_s406 (ite l1_s250 l1_s405 l1_s404)))-  (let ((l1_s407 (xor l1_s356 l1_s406)))-  (let ((l1_s408 (ite l1_s256 l1_s407 l1_s406)))-  (let ((l1_s409 (xor l1_s336 l1_s408)))-  (let ((l1_s410 (ite l1_s264 l1_s409 l1_s408)))-  (let ((l1_s411 (xor l1_s318 l1_s410)))-  (let ((l1_s412 (ite l1_s274 l1_s411 l1_s410)))-  (let ((l1_s413 (xor l1_s302 l1_s412)))-  (let ((l1_s414 (ite l1_s286 l1_s413 l1_s412)))-  (let ((l1_s415 (xor l1_s288 l1_s414)))-  (let ((l1_s416 (ite l1_s300 l1_s415 l1_s414)))-  (let ((l1_s417 (xor l1_s276 l1_s416)))-  (let ((l1_s418 (ite l1_s316 l1_s417 l1_s416)))-  (let ((l1_s419 (xor l1_s266 l1_s418)))-  (let ((l1_s420 (ite l1_s334 l1_s419 l1_s418)))-  (let ((l1_s421 (xor l1_s258 l1_s420)))-  (let ((l1_s422 (ite l1_s354 l1_s421 l1_s420)))-  (let ((l1_s423 (xor l1_s252 l1_s422)))-  (let ((l1_s424 (ite l1_s376 l1_s423 l1_s422)))-  (let ((l1_s425 (xor l1_s248 l1_s424)))-  (let ((l1_s426 (ite l1_s400 l1_s425 l1_s424)))-  (let ((l1_s427 ((_ extract 3 3) s0)))-  (let ((l1_s428 (distinct l1_s3 l1_s427)))-  (let ((l1_s429 (xor l1_s73 l1_s428)))-  (let ((l1_s430 (ite l1_s7 l1_s429 l1_s73)))-  (let ((l1_s431 (xor l1_s402 l1_s430)))-  (let ((l1_s432 (ite l1_s250 l1_s431 l1_s430)))-  (let ((l1_s433 (xor l1_s378 l1_s432)))-  (let ((l1_s434 (ite l1_s256 l1_s433 l1_s432)))-  (let ((l1_s435 (xor l1_s356 l1_s434)))-  (let ((l1_s436 (ite l1_s264 l1_s435 l1_s434)))-  (let ((l1_s437 (xor l1_s336 l1_s436)))-  (let ((l1_s438 (ite l1_s274 l1_s437 l1_s436)))-  (let ((l1_s439 (xor l1_s318 l1_s438)))-  (let ((l1_s440 (ite l1_s286 l1_s439 l1_s438)))-  (let ((l1_s441 (xor l1_s302 l1_s440)))-  (let ((l1_s442 (ite l1_s300 l1_s441 l1_s440)))-  (let ((l1_s443 (xor l1_s288 l1_s442)))-  (let ((l1_s444 (ite l1_s316 l1_s443 l1_s442)))-  (let ((l1_s445 (xor l1_s276 l1_s444)))-  (let ((l1_s446 (ite l1_s334 l1_s445 l1_s444)))-  (let ((l1_s447 (xor l1_s266 l1_s446)))-  (let ((l1_s448 (ite l1_s354 l1_s447 l1_s446)))-  (let ((l1_s449 (xor l1_s258 l1_s448)))-  (let ((l1_s450 (ite l1_s376 l1_s449 l1_s448)))-  (let ((l1_s451 (xor l1_s252 l1_s450)))-  (let ((l1_s452 (ite l1_s400 l1_s451 l1_s450)))-  (let ((l1_s453 (xor l1_s248 l1_s452)))-  (let ((l1_s454 (ite l1_s426 l1_s453 l1_s452)))-  (let ((l1_s455 ((_ extract 2 2) s0)))-  (let ((l1_s456 (distinct l1_s3 l1_s455)))-  (let ((l1_s457 (xor l1_s78 l1_s456)))-  (let ((l1_s458 (ite l1_s7 l1_s457 l1_s78)))-  (let ((l1_s459 (xor l1_s428 l1_s458)))-  (let ((l1_s460 (ite l1_s250 l1_s459 l1_s458)))-  (let ((l1_s461 (xor l1_s402 l1_s460)))-  (let ((l1_s462 (ite l1_s256 l1_s461 l1_s460)))-  (let ((l1_s463 (xor l1_s378 l1_s462)))-  (let ((l1_s464 (ite l1_s264 l1_s463 l1_s462)))-  (let ((l1_s465 (xor l1_s356 l1_s464)))-  (let ((l1_s466 (ite l1_s274 l1_s465 l1_s464)))-  (let ((l1_s467 (xor l1_s336 l1_s466)))-  (let ((l1_s468 (ite l1_s286 l1_s467 l1_s466)))-  (let ((l1_s469 (xor l1_s318 l1_s468)))-  (let ((l1_s470 (ite l1_s300 l1_s469 l1_s468)))-  (let ((l1_s471 (xor l1_s302 l1_s470)))-  (let ((l1_s472 (ite l1_s316 l1_s471 l1_s470)))-  (let ((l1_s473 (xor l1_s288 l1_s472)))-  (let ((l1_s474 (ite l1_s334 l1_s473 l1_s472)))-  (let ((l1_s475 (xor l1_s276 l1_s474)))-  (let ((l1_s476 (ite l1_s354 l1_s475 l1_s474)))-  (let ((l1_s477 (xor l1_s266 l1_s476)))-  (let ((l1_s478 (ite l1_s376 l1_s477 l1_s476)))-  (let ((l1_s479 (xor l1_s258 l1_s478)))-  (let ((l1_s480 (ite l1_s400 l1_s479 l1_s478)))-  (let ((l1_s481 (xor l1_s252 l1_s480)))-  (let ((l1_s482 (ite l1_s426 l1_s481 l1_s480)))-  (let ((l1_s483 (xor l1_s248 l1_s482)))-  (let ((l1_s484 (ite l1_s454 l1_s483 l1_s482)))-  (let ((l1_s485 ((_ extract 1 1) s0)))-  (let ((l1_s486 (distinct l1_s3 l1_s485)))-  (let ((l1_s487 (xor l1_s83 l1_s486)))-  (let ((l1_s488 (ite l1_s7 l1_s487 l1_s83)))-  (let ((l1_s489 (xor l1_s456 l1_s488)))-  (let ((l1_s490 (ite l1_s250 l1_s489 l1_s488)))-  (let ((l1_s491 (xor l1_s428 l1_s490)))-  (let ((l1_s492 (ite l1_s256 l1_s491 l1_s490)))-  (let ((l1_s493 (xor l1_s402 l1_s492)))-  (let ((l1_s494 (ite l1_s264 l1_s493 l1_s492)))-  (let ((l1_s495 (xor l1_s378 l1_s494)))-  (let ((l1_s496 (ite l1_s274 l1_s495 l1_s494)))-  (let ((l1_s497 (xor l1_s356 l1_s496)))-  (let ((l1_s498 (ite l1_s286 l1_s497 l1_s496)))-  (let ((l1_s499 (xor l1_s336 l1_s498)))-  (let ((l1_s500 (ite l1_s300 l1_s499 l1_s498)))-  (let ((l1_s501 (xor l1_s318 l1_s500)))-  (let ((l1_s502 (ite l1_s316 l1_s501 l1_s500)))-  (let ((l1_s503 (xor l1_s302 l1_s502)))-  (let ((l1_s504 (ite l1_s334 l1_s503 l1_s502)))-  (let ((l1_s505 (xor l1_s288 l1_s504)))-  (let ((l1_s506 (ite l1_s354 l1_s505 l1_s504)))-  (let ((l1_s507 (xor l1_s276 l1_s506)))-  (let ((l1_s508 (ite l1_s376 l1_s507 l1_s506)))-  (let ((l1_s509 (xor l1_s266 l1_s508)))-  (let ((l1_s510 (ite l1_s400 l1_s509 l1_s508)))-  (let ((l1_s511 (xor l1_s258 l1_s510)))-  (let ((l1_s512 (ite l1_s426 l1_s511 l1_s510)))-  (let ((l1_s513 (xor l1_s252 l1_s512)))-  (let ((l1_s514 (ite l1_s454 l1_s513 l1_s512)))-  (let ((l1_s515 (xor l1_s248 l1_s514)))-  (let ((l1_s516 (ite l1_s484 l1_s515 l1_s514)))-  (let ((l1_s517 (xor l1_s4 l1_s88)))-  (let ((l1_s518 (ite l1_s7 l1_s517 l1_s88)))-  (let ((l1_s519 (xor l1_s486 l1_s518)))-  (let ((l1_s520 (ite l1_s250 l1_s519 l1_s518)))-  (let ((l1_s521 (xor l1_s456 l1_s520)))-  (let ((l1_s522 (ite l1_s256 l1_s521 l1_s520)))-  (let ((l1_s523 (xor l1_s428 l1_s522)))-  (let ((l1_s524 (ite l1_s264 l1_s523 l1_s522)))-  (let ((l1_s525 (xor l1_s402 l1_s524)))-  (let ((l1_s526 (ite l1_s274 l1_s525 l1_s524)))-  (let ((l1_s527 (xor l1_s378 l1_s526)))-  (let ((l1_s528 (ite l1_s286 l1_s527 l1_s526)))-  (let ((l1_s529 (xor l1_s356 l1_s528)))-  (let ((l1_s530 (ite l1_s300 l1_s529 l1_s528)))-  (let ((l1_s531 (xor l1_s336 l1_s530)))-  (let ((l1_s532 (ite l1_s316 l1_s531 l1_s530)))-  (let ((l1_s533 (xor l1_s318 l1_s532)))-  (let ((l1_s534 (ite l1_s334 l1_s533 l1_s532)))-  (let ((l1_s535 (xor l1_s302 l1_s534)))-  (let ((l1_s536 (ite l1_s354 l1_s535 l1_s534)))-  (let ((l1_s537 (xor l1_s288 l1_s536)))-  (let ((l1_s538 (ite l1_s376 l1_s537 l1_s536)))-  (let ((l1_s539 (xor l1_s276 l1_s538)))-  (let ((l1_s540 (ite l1_s400 l1_s539 l1_s538)))-  (let ((l1_s541 (xor l1_s266 l1_s540)))-  (let ((l1_s542 (ite l1_s426 l1_s541 l1_s540)))-  (let ((l1_s543 (xor l1_s258 l1_s542)))-  (let ((l1_s544 (ite l1_s454 l1_s543 l1_s542)))-  (let ((l1_s545 (xor l1_s252 l1_s544)))-  (let ((l1_s546 (ite l1_s484 l1_s545 l1_s544)))-  (let ((l1_s547 (xor l1_s248 l1_s546)))-  (let ((l1_s548 (ite l1_s516 l1_s547 l1_s546)))-  (let ((l1_s549 (xor l1_s4 l1_s93)))-  (let ((l1_s550 (ite l1_s250 l1_s549 l1_s93)))-  (let ((l1_s551 (xor l1_s486 l1_s550)))-  (let ((l1_s552 (ite l1_s256 l1_s551 l1_s550)))-  (let ((l1_s553 (xor l1_s456 l1_s552)))-  (let ((l1_s554 (ite l1_s264 l1_s553 l1_s552)))-  (let ((l1_s555 (xor l1_s428 l1_s554)))-  (let ((l1_s556 (ite l1_s274 l1_s555 l1_s554)))-  (let ((l1_s557 (xor l1_s402 l1_s556)))-  (let ((l1_s558 (ite l1_s286 l1_s557 l1_s556)))-  (let ((l1_s559 (xor l1_s378 l1_s558)))-  (let ((l1_s560 (ite l1_s300 l1_s559 l1_s558)))-  (let ((l1_s561 (xor l1_s356 l1_s560)))-  (let ((l1_s562 (ite l1_s316 l1_s561 l1_s560)))-  (let ((l1_s563 (xor l1_s336 l1_s562)))-  (let ((l1_s564 (ite l1_s334 l1_s563 l1_s562)))-  (let ((l1_s565 (xor l1_s318 l1_s564)))-  (let ((l1_s566 (ite l1_s354 l1_s565 l1_s564)))-  (let ((l1_s567 (xor l1_s302 l1_s566)))-  (let ((l1_s568 (ite l1_s376 l1_s567 l1_s566)))-  (let ((l1_s569 (xor l1_s288 l1_s568)))-  (let ((l1_s570 (ite l1_s400 l1_s569 l1_s568)))-  (let ((l1_s571 (xor l1_s276 l1_s570)))-  (let ((l1_s572 (ite l1_s426 l1_s571 l1_s570)))-  (let ((l1_s573 (xor l1_s266 l1_s572)))-  (let ((l1_s574 (ite l1_s454 l1_s573 l1_s572)))-  (let ((l1_s575 (xor l1_s258 l1_s574)))-  (let ((l1_s576 (ite l1_s484 l1_s575 l1_s574)))-  (let ((l1_s577 (xor l1_s252 l1_s576)))-  (let ((l1_s578 (ite l1_s516 l1_s577 l1_s576)))-  (let ((l1_s579 (xor l1_s248 l1_s578)))-  (let ((l1_s580 (ite l1_s548 l1_s579 l1_s578)))-  (let ((l1_s581 (xor l1_s4 l1_s98)))-  (let ((l1_s582 (ite l1_s256 l1_s581 l1_s98)))-  (let ((l1_s583 (xor l1_s486 l1_s582)))-  (let ((l1_s584 (ite l1_s264 l1_s583 l1_s582)))-  (let ((l1_s585 (xor l1_s456 l1_s584)))-  (let ((l1_s586 (ite l1_s274 l1_s585 l1_s584)))-  (let ((l1_s587 (xor l1_s428 l1_s586)))-  (let ((l1_s588 (ite l1_s286 l1_s587 l1_s586)))-  (let ((l1_s589 (xor l1_s402 l1_s588)))-  (let ((l1_s590 (ite l1_s300 l1_s589 l1_s588)))-  (let ((l1_s591 (xor l1_s378 l1_s590)))-  (let ((l1_s592 (ite l1_s316 l1_s591 l1_s590)))-  (let ((l1_s593 (xor l1_s356 l1_s592)))-  (let ((l1_s594 (ite l1_s334 l1_s593 l1_s592)))-  (let ((l1_s595 (xor l1_s336 l1_s594)))-  (let ((l1_s596 (ite l1_s354 l1_s595 l1_s594)))-  (let ((l1_s597 (xor l1_s318 l1_s596)))-  (let ((l1_s598 (ite l1_s376 l1_s597 l1_s596)))-  (let ((l1_s599 (xor l1_s302 l1_s598)))-  (let ((l1_s600 (ite l1_s400 l1_s599 l1_s598)))-  (let ((l1_s601 (xor l1_s288 l1_s600)))-  (let ((l1_s602 (ite l1_s426 l1_s601 l1_s600)))-  (let ((l1_s603 (xor l1_s276 l1_s602)))-  (let ((l1_s604 (ite l1_s454 l1_s603 l1_s602)))-  (let ((l1_s605 (xor l1_s266 l1_s604)))-  (let ((l1_s606 (ite l1_s484 l1_s605 l1_s604)))-  (let ((l1_s607 (xor l1_s258 l1_s606)))-  (let ((l1_s608 (ite l1_s516 l1_s607 l1_s606)))-  (let ((l1_s609 (xor l1_s252 l1_s608)))-  (let ((l1_s610 (ite l1_s548 l1_s609 l1_s608)))-  (let ((l1_s611 (xor l1_s248 l1_s610)))-  (let ((l1_s612 (ite l1_s580 l1_s611 l1_s610)))-  (let ((l1_s613 (xor l1_s4 l1_s103)))-  (let ((l1_s614 (ite l1_s264 l1_s613 l1_s103)))-  (let ((l1_s615 (xor l1_s486 l1_s614)))-  (let ((l1_s616 (ite l1_s274 l1_s615 l1_s614)))-  (let ((l1_s617 (xor l1_s456 l1_s616)))-  (let ((l1_s618 (ite l1_s286 l1_s617 l1_s616)))-  (let ((l1_s619 (xor l1_s428 l1_s618)))-  (let ((l1_s620 (ite l1_s300 l1_s619 l1_s618)))-  (let ((l1_s621 (xor l1_s402 l1_s620)))-  (let ((l1_s622 (ite l1_s316 l1_s621 l1_s620)))-  (let ((l1_s623 (xor l1_s378 l1_s622)))-  (let ((l1_s624 (ite l1_s334 l1_s623 l1_s622)))-  (let ((l1_s625 (xor l1_s356 l1_s624)))-  (let ((l1_s626 (ite l1_s354 l1_s625 l1_s624)))-  (let ((l1_s627 (xor l1_s336 l1_s626)))-  (let ((l1_s628 (ite l1_s376 l1_s627 l1_s626)))-  (let ((l1_s629 (xor l1_s318 l1_s628)))-  (let ((l1_s630 (ite l1_s400 l1_s629 l1_s628)))-  (let ((l1_s631 (xor l1_s302 l1_s630)))-  (let ((l1_s632 (ite l1_s426 l1_s631 l1_s630)))-  (let ((l1_s633 (xor l1_s288 l1_s632)))-  (let ((l1_s634 (ite l1_s454 l1_s633 l1_s632)))-  (let ((l1_s635 (xor l1_s276 l1_s634)))-  (let ((l1_s636 (ite l1_s484 l1_s635 l1_s634)))-  (let ((l1_s637 (xor l1_s266 l1_s636)))-  (let ((l1_s638 (ite l1_s516 l1_s637 l1_s636)))-  (let ((l1_s639 (xor l1_s258 l1_s638)))-  (let ((l1_s640 (ite l1_s548 l1_s639 l1_s638)))-  (let ((l1_s641 (xor l1_s252 l1_s640)))-  (let ((l1_s642 (ite l1_s580 l1_s641 l1_s640)))-  (let ((l1_s643 (xor l1_s248 l1_s642)))-  (let ((l1_s644 (ite l1_s612 l1_s643 l1_s642)))-  (let ((l1_s645 (xor l1_s4 l1_s108)))-  (let ((l1_s646 (ite l1_s274 l1_s645 l1_s108)))-  (let ((l1_s647 (xor l1_s486 l1_s646)))-  (let ((l1_s648 (ite l1_s286 l1_s647 l1_s646)))-  (let ((l1_s649 (xor l1_s456 l1_s648)))-  (let ((l1_s650 (ite l1_s300 l1_s649 l1_s648)))-  (let ((l1_s651 (xor l1_s428 l1_s650)))-  (let ((l1_s652 (ite l1_s316 l1_s651 l1_s650)))-  (let ((l1_s653 (xor l1_s402 l1_s652)))-  (let ((l1_s654 (ite l1_s334 l1_s653 l1_s652)))-  (let ((l1_s655 (xor l1_s378 l1_s654)))-  (let ((l1_s656 (ite l1_s354 l1_s655 l1_s654)))-  (let ((l1_s657 (xor l1_s356 l1_s656)))-  (let ((l1_s658 (ite l1_s376 l1_s657 l1_s656)))-  (let ((l1_s659 (xor l1_s336 l1_s658)))-  (let ((l1_s660 (ite l1_s400 l1_s659 l1_s658)))-  (let ((l1_s661 (xor l1_s318 l1_s660)))-  (let ((l1_s662 (ite l1_s426 l1_s661 l1_s660)))-  (let ((l1_s663 (xor l1_s302 l1_s662)))-  (let ((l1_s664 (ite l1_s454 l1_s663 l1_s662)))-  (let ((l1_s665 (xor l1_s288 l1_s664)))-  (let ((l1_s666 (ite l1_s484 l1_s665 l1_s664)))-  (let ((l1_s667 (xor l1_s276 l1_s666)))-  (let ((l1_s668 (ite l1_s516 l1_s667 l1_s666)))-  (let ((l1_s669 (xor l1_s266 l1_s668)))-  (let ((l1_s670 (ite l1_s548 l1_s669 l1_s668)))-  (let ((l1_s671 (xor l1_s258 l1_s670)))-  (let ((l1_s672 (ite l1_s580 l1_s671 l1_s670)))-  (let ((l1_s673 (xor l1_s252 l1_s672)))-  (let ((l1_s674 (ite l1_s612 l1_s673 l1_s672)))-  (let ((l1_s675 (xor l1_s248 l1_s674)))-  (let ((l1_s676 (ite l1_s644 l1_s675 l1_s674)))-  (let ((l1_s677 (xor l1_s4 l1_s113)))-  (let ((l1_s678 (ite l1_s286 l1_s677 l1_s113)))-  (let ((l1_s679 (xor l1_s486 l1_s678)))-  (let ((l1_s680 (ite l1_s300 l1_s679 l1_s678)))-  (let ((l1_s681 (xor l1_s456 l1_s680)))-  (let ((l1_s682 (ite l1_s316 l1_s681 l1_s680)))-  (let ((l1_s683 (xor l1_s428 l1_s682)))-  (let ((l1_s684 (ite l1_s334 l1_s683 l1_s682)))-  (let ((l1_s685 (xor l1_s402 l1_s684)))-  (let ((l1_s686 (ite l1_s354 l1_s685 l1_s684)))-  (let ((l1_s687 (xor l1_s378 l1_s686)))-  (let ((l1_s688 (ite l1_s376 l1_s687 l1_s686)))-  (let ((l1_s689 (xor l1_s356 l1_s688)))-  (let ((l1_s690 (ite l1_s400 l1_s689 l1_s688)))-  (let ((l1_s691 (xor l1_s336 l1_s690)))-  (let ((l1_s692 (ite l1_s426 l1_s691 l1_s690)))-  (let ((l1_s693 (xor l1_s318 l1_s692)))-  (let ((l1_s694 (ite l1_s454 l1_s693 l1_s692)))-  (let ((l1_s695 (xor l1_s302 l1_s694)))-  (let ((l1_s696 (ite l1_s484 l1_s695 l1_s694)))-  (let ((l1_s697 (xor l1_s288 l1_s696)))-  (let ((l1_s698 (ite l1_s516 l1_s697 l1_s696)))-  (let ((l1_s699 (xor l1_s276 l1_s698)))-  (let ((l1_s700 (ite l1_s548 l1_s699 l1_s698)))-  (let ((l1_s701 (xor l1_s266 l1_s700)))-  (let ((l1_s702 (ite l1_s580 l1_s701 l1_s700)))-  (let ((l1_s703 (xor l1_s258 l1_s702)))-  (let ((l1_s704 (ite l1_s612 l1_s703 l1_s702)))-  (let ((l1_s705 (xor l1_s252 l1_s704)))-  (let ((l1_s706 (ite l1_s644 l1_s705 l1_s704)))-  (let ((l1_s707 (xor l1_s248 l1_s706)))-  (let ((l1_s708 (ite l1_s676 l1_s707 l1_s706)))-  (let ((l1_s709 (xor l1_s4 l1_s118)))-  (let ((l1_s710 (ite l1_s300 l1_s709 l1_s118)))-  (let ((l1_s711 (xor l1_s486 l1_s710)))-  (let ((l1_s712 (ite l1_s316 l1_s711 l1_s710)))-  (let ((l1_s713 (xor l1_s456 l1_s712)))-  (let ((l1_s714 (ite l1_s334 l1_s713 l1_s712)))-  (let ((l1_s715 (xor l1_s428 l1_s714)))-  (let ((l1_s716 (ite l1_s354 l1_s715 l1_s714)))-  (let ((l1_s717 (xor l1_s402 l1_s716)))-  (let ((l1_s718 (ite l1_s376 l1_s717 l1_s716)))-  (let ((l1_s719 (xor l1_s378 l1_s718)))-  (let ((l1_s720 (ite l1_s400 l1_s719 l1_s718)))-  (let ((l1_s721 (xor l1_s356 l1_s720)))-  (let ((l1_s722 (ite l1_s426 l1_s721 l1_s720)))-  (let ((l1_s723 (xor l1_s336 l1_s722)))-  (let ((l1_s724 (ite l1_s454 l1_s723 l1_s722)))-  (let ((l1_s725 (xor l1_s318 l1_s724)))-  (let ((l1_s726 (ite l1_s484 l1_s725 l1_s724)))-  (let ((l1_s727 (xor l1_s302 l1_s726)))-  (let ((l1_s728 (ite l1_s516 l1_s727 l1_s726)))-  (let ((l1_s729 (xor l1_s288 l1_s728)))-  (let ((l1_s730 (ite l1_s548 l1_s729 l1_s728)))-  (let ((l1_s731 (xor l1_s276 l1_s730)))-  (let ((l1_s732 (ite l1_s580 l1_s731 l1_s730)))-  (let ((l1_s733 (xor l1_s266 l1_s732)))-  (let ((l1_s734 (ite l1_s612 l1_s733 l1_s732)))-  (let ((l1_s735 (xor l1_s258 l1_s734)))-  (let ((l1_s736 (ite l1_s644 l1_s735 l1_s734)))-  (let ((l1_s737 (xor l1_s252 l1_s736)))-  (let ((l1_s738 (ite l1_s676 l1_s737 l1_s736)))-  (let ((l1_s739 (xor l1_s248 l1_s738)))-  (let ((l1_s740 (ite l1_s708 l1_s739 l1_s738)))-  (let ((l1_s741 (xor l1_s4 l1_s123)))-  (let ((l1_s742 (ite l1_s316 l1_s741 l1_s123)))-  (let ((l1_s743 (xor l1_s486 l1_s742)))-  (let ((l1_s744 (ite l1_s334 l1_s743 l1_s742)))-  (let ((l1_s745 (xor l1_s456 l1_s744)))-  (let ((l1_s746 (ite l1_s354 l1_s745 l1_s744)))-  (let ((l1_s747 (xor l1_s428 l1_s746)))-  (let ((l1_s748 (ite l1_s376 l1_s747 l1_s746)))-  (let ((l1_s749 (xor l1_s402 l1_s748)))-  (let ((l1_s750 (ite l1_s400 l1_s749 l1_s748)))-  (let ((l1_s751 (xor l1_s378 l1_s750)))-  (let ((l1_s752 (ite l1_s426 l1_s751 l1_s750)))-  (let ((l1_s753 (xor l1_s356 l1_s752)))-  (let ((l1_s754 (ite l1_s454 l1_s753 l1_s752)))-  (let ((l1_s755 (xor l1_s336 l1_s754)))-  (let ((l1_s756 (ite l1_s484 l1_s755 l1_s754)))-  (let ((l1_s757 (xor l1_s318 l1_s756)))-  (let ((l1_s758 (ite l1_s516 l1_s757 l1_s756)))-  (let ((l1_s759 (xor l1_s302 l1_s758)))-  (let ((l1_s760 (ite l1_s548 l1_s759 l1_s758)))-  (let ((l1_s761 (xor l1_s288 l1_s760)))-  (let ((l1_s762 (ite l1_s580 l1_s761 l1_s760)))-  (let ((l1_s763 (xor l1_s276 l1_s762)))-  (let ((l1_s764 (ite l1_s612 l1_s763 l1_s762)))-  (let ((l1_s765 (xor l1_s266 l1_s764)))-  (let ((l1_s766 (ite l1_s644 l1_s765 l1_s764)))-  (let ((l1_s767 (xor l1_s258 l1_s766)))-  (let ((l1_s768 (ite l1_s676 l1_s767 l1_s766)))-  (let ((l1_s769 (xor l1_s252 l1_s768)))-  (let ((l1_s770 (ite l1_s708 l1_s769 l1_s768)))-  (let ((l1_s771 (xor l1_s248 l1_s770)))-  (let ((l1_s772 (ite l1_s740 l1_s771 l1_s770)))-  (let ((l1_s773 (xor l1_s4 l1_s128)))-  (let ((l1_s774 (ite l1_s334 l1_s773 l1_s128)))-  (let ((l1_s775 (xor l1_s486 l1_s774)))-  (let ((l1_s776 (ite l1_s354 l1_s775 l1_s774)))-  (let ((l1_s777 (xor l1_s456 l1_s776)))-  (let ((l1_s778 (ite l1_s376 l1_s777 l1_s776)))-  (let ((l1_s779 (xor l1_s428 l1_s778)))-  (let ((l1_s780 (ite l1_s400 l1_s779 l1_s778)))-  (let ((l1_s781 (xor l1_s402 l1_s780)))-  (let ((l1_s782 (ite l1_s426 l1_s781 l1_s780)))-  (let ((l1_s783 (xor l1_s378 l1_s782)))-  (let ((l1_s784 (ite l1_s454 l1_s783 l1_s782)))-  (let ((l1_s785 (xor l1_s356 l1_s784)))-  (let ((l1_s786 (ite l1_s484 l1_s785 l1_s784)))-  (let ((l1_s787 (xor l1_s336 l1_s786)))-  (let ((l1_s788 (ite l1_s516 l1_s787 l1_s786)))-  (let ((l1_s789 (xor l1_s318 l1_s788)))-  (let ((l1_s790 (ite l1_s548 l1_s789 l1_s788)))-  (let ((l1_s791 (xor l1_s302 l1_s790)))-  (let ((l1_s792 (ite l1_s580 l1_s791 l1_s790)))-  (let ((l1_s793 (xor l1_s288 l1_s792)))-  (let ((l1_s794 (ite l1_s612 l1_s793 l1_s792)))-  (let ((l1_s795 (xor l1_s276 l1_s794)))-  (let ((l1_s796 (ite l1_s644 l1_s795 l1_s794)))-  (let ((l1_s797 (xor l1_s266 l1_s796)))-  (let ((l1_s798 (ite l1_s676 l1_s797 l1_s796)))-  (let ((l1_s799 (xor l1_s258 l1_s798)))-  (let ((l1_s800 (ite l1_s708 l1_s799 l1_s798)))-  (let ((l1_s801 (xor l1_s252 l1_s800)))-  (let ((l1_s802 (ite l1_s740 l1_s801 l1_s800)))-  (let ((l1_s803 (xor l1_s248 l1_s802)))-  (let ((l1_s804 (ite l1_s772 l1_s803 l1_s802)))-  (let ((l1_s805 (xor l1_s4 l1_s133)))-  (let ((l1_s806 (ite l1_s354 l1_s805 l1_s133)))-  (let ((l1_s807 (xor l1_s486 l1_s806)))-  (let ((l1_s808 (ite l1_s376 l1_s807 l1_s806)))-  (let ((l1_s809 (xor l1_s456 l1_s808)))-  (let ((l1_s810 (ite l1_s400 l1_s809 l1_s808)))-  (let ((l1_s811 (xor l1_s428 l1_s810)))-  (let ((l1_s812 (ite l1_s426 l1_s811 l1_s810)))-  (let ((l1_s813 (xor l1_s402 l1_s812)))-  (let ((l1_s814 (ite l1_s454 l1_s813 l1_s812)))-  (let ((l1_s815 (xor l1_s378 l1_s814)))-  (let ((l1_s816 (ite l1_s484 l1_s815 l1_s814)))-  (let ((l1_s817 (xor l1_s356 l1_s816)))-  (let ((l1_s818 (ite l1_s516 l1_s817 l1_s816)))-  (let ((l1_s819 (xor l1_s336 l1_s818)))-  (let ((l1_s820 (ite l1_s548 l1_s819 l1_s818)))-  (let ((l1_s821 (xor l1_s318 l1_s820)))-  (let ((l1_s822 (ite l1_s580 l1_s821 l1_s820)))-  (let ((l1_s823 (xor l1_s302 l1_s822)))-  (let ((l1_s824 (ite l1_s612 l1_s823 l1_s822)))-  (let ((l1_s825 (xor l1_s288 l1_s824)))-  (let ((l1_s826 (ite l1_s644 l1_s825 l1_s824)))-  (let ((l1_s827 (xor l1_s276 l1_s826)))-  (let ((l1_s828 (ite l1_s676 l1_s827 l1_s826)))-  (let ((l1_s829 (xor l1_s266 l1_s828)))-  (let ((l1_s830 (ite l1_s708 l1_s829 l1_s828)))-  (let ((l1_s831 (xor l1_s258 l1_s830)))-  (let ((l1_s832 (ite l1_s740 l1_s831 l1_s830)))-  (let ((l1_s833 (xor l1_s252 l1_s832)))-  (let ((l1_s834 (ite l1_s772 l1_s833 l1_s832)))-  (let ((l1_s835 (xor l1_s248 l1_s834)))-  (let ((l1_s836 (ite l1_s804 l1_s835 l1_s834)))-  (let ((l1_s837 (xor l1_s4 l1_s138)))-  (let ((l1_s838 (ite l1_s376 l1_s837 l1_s138)))-  (let ((l1_s839 (xor l1_s486 l1_s838)))-  (let ((l1_s840 (ite l1_s400 l1_s839 l1_s838)))-  (let ((l1_s841 (xor l1_s456 l1_s840)))-  (let ((l1_s842 (ite l1_s426 l1_s841 l1_s840)))-  (let ((l1_s843 (xor l1_s428 l1_s842)))-  (let ((l1_s844 (ite l1_s454 l1_s843 l1_s842)))-  (let ((l1_s845 (xor l1_s402 l1_s844)))-  (let ((l1_s846 (ite l1_s484 l1_s845 l1_s844)))-  (let ((l1_s847 (xor l1_s378 l1_s846)))-  (let ((l1_s848 (ite l1_s516 l1_s847 l1_s846)))-  (let ((l1_s849 (xor l1_s356 l1_s848)))-  (let ((l1_s850 (ite l1_s548 l1_s849 l1_s848)))-  (let ((l1_s851 (xor l1_s336 l1_s850)))-  (let ((l1_s852 (ite l1_s580 l1_s851 l1_s850)))-  (let ((l1_s853 (xor l1_s318 l1_s852)))-  (let ((l1_s854 (ite l1_s612 l1_s853 l1_s852)))-  (let ((l1_s855 (xor l1_s302 l1_s854)))-  (let ((l1_s856 (ite l1_s644 l1_s855 l1_s854)))-  (let ((l1_s857 (xor l1_s288 l1_s856)))-  (let ((l1_s858 (ite l1_s676 l1_s857 l1_s856)))-  (let ((l1_s859 (xor l1_s276 l1_s858)))-  (let ((l1_s860 (ite l1_s708 l1_s859 l1_s858)))-  (let ((l1_s861 (xor l1_s266 l1_s860)))-  (let ((l1_s862 (ite l1_s740 l1_s861 l1_s860)))-  (let ((l1_s863 (xor l1_s258 l1_s862)))-  (let ((l1_s864 (ite l1_s772 l1_s863 l1_s862)))-  (let ((l1_s865 (xor l1_s252 l1_s864)))-  (let ((l1_s866 (ite l1_s804 l1_s865 l1_s864)))-  (let ((l1_s867 (xor l1_s248 l1_s866)))-  (let ((l1_s868 (ite l1_s836 l1_s867 l1_s866)))-  (let ((l1_s869 (xor l1_s4 l1_s143)))-  (let ((l1_s870 (ite l1_s400 l1_s869 l1_s143)))-  (let ((l1_s871 (xor l1_s486 l1_s870)))-  (let ((l1_s872 (ite l1_s426 l1_s871 l1_s870)))-  (let ((l1_s873 (xor l1_s456 l1_s872)))-  (let ((l1_s874 (ite l1_s454 l1_s873 l1_s872)))-  (let ((l1_s875 (xor l1_s428 l1_s874)))-  (let ((l1_s876 (ite l1_s484 l1_s875 l1_s874)))-  (let ((l1_s877 (xor l1_s402 l1_s876)))-  (let ((l1_s878 (ite l1_s516 l1_s877 l1_s876)))-  (let ((l1_s879 (xor l1_s378 l1_s878)))-  (let ((l1_s880 (ite l1_s548 l1_s879 l1_s878)))-  (let ((l1_s881 (xor l1_s356 l1_s880)))-  (let ((l1_s882 (ite l1_s580 l1_s881 l1_s880)))-  (let ((l1_s883 (xor l1_s336 l1_s882)))-  (let ((l1_s884 (ite l1_s612 l1_s883 l1_s882)))-  (let ((l1_s885 (xor l1_s318 l1_s884)))-  (let ((l1_s886 (ite l1_s644 l1_s885 l1_s884)))-  (let ((l1_s887 (xor l1_s302 l1_s886)))-  (let ((l1_s888 (ite l1_s676 l1_s887 l1_s886)))-  (let ((l1_s889 (xor l1_s288 l1_s888)))-  (let ((l1_s890 (ite l1_s708 l1_s889 l1_s888)))-  (let ((l1_s891 (xor l1_s276 l1_s890)))-  (let ((l1_s892 (ite l1_s740 l1_s891 l1_s890)))-  (let ((l1_s893 (xor l1_s266 l1_s892)))-  (let ((l1_s894 (ite l1_s772 l1_s893 l1_s892)))-  (let ((l1_s895 (xor l1_s258 l1_s894)))-  (let ((l1_s896 (ite l1_s804 l1_s895 l1_s894)))-  (let ((l1_s897 (xor l1_s252 l1_s896)))-  (let ((l1_s898 (ite l1_s836 l1_s897 l1_s896)))-  (let ((l1_s899 (xor l1_s248 l1_s898)))-  (let ((l1_s900 (ite l1_s868 l1_s899 l1_s898)))-  (let ((l1_s901 (xor l1_s4 l1_s148)))-  (let ((l1_s902 (ite l1_s426 l1_s901 l1_s148)))-  (let ((l1_s903 (xor l1_s486 l1_s902)))-  (let ((l1_s904 (ite l1_s454 l1_s903 l1_s902)))-  (let ((l1_s905 (xor l1_s456 l1_s904)))-  (let ((l1_s906 (ite l1_s484 l1_s905 l1_s904)))-  (let ((l1_s907 (xor l1_s428 l1_s906)))-  (let ((l1_s908 (ite l1_s516 l1_s907 l1_s906)))-  (let ((l1_s909 (xor l1_s402 l1_s908)))-  (let ((l1_s910 (ite l1_s548 l1_s909 l1_s908)))-  (let ((l1_s911 (xor l1_s378 l1_s910)))-  (let ((l1_s912 (ite l1_s580 l1_s911 l1_s910)))-  (let ((l1_s913 (xor l1_s356 l1_s912)))-  (let ((l1_s914 (ite l1_s612 l1_s913 l1_s912)))-  (let ((l1_s915 (xor l1_s336 l1_s914)))-  (let ((l1_s916 (ite l1_s644 l1_s915 l1_s914)))-  (let ((l1_s917 (xor l1_s318 l1_s916)))-  (let ((l1_s918 (ite l1_s676 l1_s917 l1_s916)))-  (let ((l1_s919 (xor l1_s302 l1_s918)))-  (let ((l1_s920 (ite l1_s708 l1_s919 l1_s918)))-  (let ((l1_s921 (xor l1_s288 l1_s920)))-  (let ((l1_s922 (ite l1_s740 l1_s921 l1_s920)))-  (let ((l1_s923 (xor l1_s276 l1_s922)))-  (let ((l1_s924 (ite l1_s772 l1_s923 l1_s922)))-  (let ((l1_s925 (xor l1_s266 l1_s924)))-  (let ((l1_s926 (ite l1_s804 l1_s925 l1_s924)))-  (let ((l1_s927 (xor l1_s258 l1_s926)))-  (let ((l1_s928 (ite l1_s836 l1_s927 l1_s926)))-  (let ((l1_s929 (xor l1_s252 l1_s928)))-  (let ((l1_s930 (ite l1_s868 l1_s929 l1_s928)))-  (let ((l1_s931 (xor l1_s248 l1_s930)))-  (let ((l1_s932 (ite l1_s900 l1_s931 l1_s930)))-  (let ((l1_s933 (xor l1_s4 l1_s153)))-  (let ((l1_s934 (ite l1_s454 l1_s933 l1_s153)))-  (let ((l1_s935 (xor l1_s486 l1_s934)))-  (let ((l1_s936 (ite l1_s484 l1_s935 l1_s934)))-  (let ((l1_s937 (xor l1_s456 l1_s936)))-  (let ((l1_s938 (ite l1_s516 l1_s937 l1_s936)))-  (let ((l1_s939 (xor l1_s428 l1_s938)))-  (let ((l1_s940 (ite l1_s548 l1_s939 l1_s938)))-  (let ((l1_s941 (xor l1_s402 l1_s940)))-  (let ((l1_s942 (ite l1_s580 l1_s941 l1_s940)))-  (let ((l1_s943 (xor l1_s378 l1_s942)))-  (let ((l1_s944 (ite l1_s612 l1_s943 l1_s942)))-  (let ((l1_s945 (xor l1_s356 l1_s944)))-  (let ((l1_s946 (ite l1_s644 l1_s945 l1_s944)))-  (let ((l1_s947 (xor l1_s336 l1_s946)))-  (let ((l1_s948 (ite l1_s676 l1_s947 l1_s946)))-  (let ((l1_s949 (xor l1_s318 l1_s948)))-  (let ((l1_s950 (ite l1_s708 l1_s949 l1_s948)))-  (let ((l1_s951 (xor l1_s302 l1_s950)))-  (let ((l1_s952 (ite l1_s740 l1_s951 l1_s950)))-  (let ((l1_s953 (xor l1_s288 l1_s952)))-  (let ((l1_s954 (ite l1_s772 l1_s953 l1_s952)))-  (let ((l1_s955 (xor l1_s276 l1_s954)))-  (let ((l1_s956 (ite l1_s804 l1_s955 l1_s954)))-  (let ((l1_s957 (xor l1_s266 l1_s956)))-  (let ((l1_s958 (ite l1_s836 l1_s957 l1_s956)))-  (let ((l1_s959 (xor l1_s258 l1_s958)))-  (let ((l1_s960 (ite l1_s868 l1_s959 l1_s958)))-  (let ((l1_s961 (xor l1_s252 l1_s960)))-  (let ((l1_s962 (ite l1_s900 l1_s961 l1_s960)))-  (let ((l1_s963 (xor l1_s248 l1_s962)))-  (let ((l1_s964 (ite l1_s932 l1_s963 l1_s962)))-  (let ((l1_s965 (xor l1_s4 l1_s158)))-  (let ((l1_s966 (ite l1_s484 l1_s965 l1_s158)))-  (let ((l1_s967 (xor l1_s486 l1_s966)))-  (let ((l1_s968 (ite l1_s516 l1_s967 l1_s966)))-  (let ((l1_s969 (xor l1_s456 l1_s968)))-  (let ((l1_s970 (ite l1_s548 l1_s969 l1_s968)))-  (let ((l1_s971 (xor l1_s428 l1_s970)))-  (let ((l1_s972 (ite l1_s580 l1_s971 l1_s970)))-  (let ((l1_s973 (xor l1_s402 l1_s972)))-  (let ((l1_s974 (ite l1_s612 l1_s973 l1_s972)))-  (let ((l1_s975 (xor l1_s378 l1_s974)))-  (let ((l1_s976 (ite l1_s644 l1_s975 l1_s974)))-  (let ((l1_s977 (xor l1_s356 l1_s976)))-  (let ((l1_s978 (ite l1_s676 l1_s977 l1_s976)))-  (let ((l1_s979 (xor l1_s336 l1_s978)))-  (let ((l1_s980 (ite l1_s708 l1_s979 l1_s978)))-  (let ((l1_s981 (xor l1_s318 l1_s980)))-  (let ((l1_s982 (ite l1_s740 l1_s981 l1_s980)))-  (let ((l1_s983 (xor l1_s302 l1_s982)))-  (let ((l1_s984 (ite l1_s772 l1_s983 l1_s982)))-  (let ((l1_s985 (xor l1_s288 l1_s984)))-  (let ((l1_s986 (ite l1_s804 l1_s985 l1_s984)))-  (let ((l1_s987 (xor l1_s276 l1_s986)))-  (let ((l1_s988 (ite l1_s836 l1_s987 l1_s986)))-  (let ((l1_s989 (xor l1_s266 l1_s988)))-  (let ((l1_s990 (ite l1_s868 l1_s989 l1_s988)))-  (let ((l1_s991 (xor l1_s258 l1_s990)))-  (let ((l1_s992 (ite l1_s900 l1_s991 l1_s990)))-  (let ((l1_s993 (xor l1_s252 l1_s992)))-  (let ((l1_s994 (ite l1_s932 l1_s993 l1_s992)))-  (let ((l1_s995 (xor l1_s248 l1_s994)))-  (let ((l1_s996 (ite l1_s964 l1_s995 l1_s994)))-  (let ((l1_s997 (xor l1_s4 l1_s163)))-  (let ((l1_s998 (ite l1_s516 l1_s997 l1_s163)))-  (let ((l1_s999 (xor l1_s486 l1_s998)))-  (let ((l1_s1000 (ite l1_s548 l1_s999 l1_s998)))-  (let ((l1_s1001 (xor l1_s456 l1_s1000)))-  (let ((l1_s1002 (ite l1_s580 l1_s1001 l1_s1000)))-  (let ((l1_s1003 (xor l1_s428 l1_s1002)))-  (let ((l1_s1004 (ite l1_s612 l1_s1003 l1_s1002)))-  (let ((l1_s1005 (xor l1_s402 l1_s1004)))-  (let ((l1_s1006 (ite l1_s644 l1_s1005 l1_s1004)))-  (let ((l1_s1007 (xor l1_s378 l1_s1006)))-  (let ((l1_s1008 (ite l1_s676 l1_s1007 l1_s1006)))-  (let ((l1_s1009 (xor l1_s356 l1_s1008)))-  (let ((l1_s1010 (ite l1_s708 l1_s1009 l1_s1008)))-  (let ((l1_s1011 (xor l1_s336 l1_s1010)))-  (let ((l1_s1012 (ite l1_s740 l1_s1011 l1_s1010)))-  (let ((l1_s1013 (xor l1_s318 l1_s1012)))-  (let ((l1_s1014 (ite l1_s772 l1_s1013 l1_s1012)))-  (let ((l1_s1015 (xor l1_s302 l1_s1014)))-  (let ((l1_s1016 (ite l1_s804 l1_s1015 l1_s1014)))-  (let ((l1_s1017 (xor l1_s288 l1_s1016)))-  (let ((l1_s1018 (ite l1_s836 l1_s1017 l1_s1016)))-  (let ((l1_s1019 (xor l1_s276 l1_s1018)))-  (let ((l1_s1020 (ite l1_s868 l1_s1019 l1_s1018)))-  (let ((l1_s1021 (xor l1_s266 l1_s1020)))-  (let ((l1_s1022 (ite l1_s900 l1_s1021 l1_s1020)))-  (let ((l1_s1023 (xor l1_s258 l1_s1022)))-  (let ((l1_s1024 (ite l1_s932 l1_s1023 l1_s1022)))-  (let ((l1_s1025 (xor l1_s252 l1_s1024)))-  (let ((l1_s1026 (ite l1_s964 l1_s1025 l1_s1024)))-  (let ((l1_s1027 (xor l1_s248 l1_s1026)))-  (let ((l1_s1028 (ite l1_s996 l1_s1027 l1_s1026)))-  (let ((l1_s1029 (xor l1_s4 l1_s168)))-  (let ((l1_s1030 (ite l1_s548 l1_s1029 l1_s168)))-  (let ((l1_s1031 (xor l1_s486 l1_s1030)))-  (let ((l1_s1032 (ite l1_s580 l1_s1031 l1_s1030)))-  (let ((l1_s1033 (xor l1_s456 l1_s1032)))-  (let ((l1_s1034 (ite l1_s612 l1_s1033 l1_s1032)))-  (let ((l1_s1035 (xor l1_s428 l1_s1034)))-  (let ((l1_s1036 (ite l1_s644 l1_s1035 l1_s1034)))-  (let ((l1_s1037 (xor l1_s402 l1_s1036)))-  (let ((l1_s1038 (ite l1_s676 l1_s1037 l1_s1036)))-  (let ((l1_s1039 (xor l1_s378 l1_s1038)))-  (let ((l1_s1040 (ite l1_s708 l1_s1039 l1_s1038)))-  (let ((l1_s1041 (xor l1_s356 l1_s1040)))-  (let ((l1_s1042 (ite l1_s740 l1_s1041 l1_s1040)))-  (let ((l1_s1043 (xor l1_s336 l1_s1042)))-  (let ((l1_s1044 (ite l1_s772 l1_s1043 l1_s1042)))-  (let ((l1_s1045 (xor l1_s318 l1_s1044)))-  (let ((l1_s1046 (ite l1_s804 l1_s1045 l1_s1044)))-  (let ((l1_s1047 (xor l1_s302 l1_s1046)))-  (let ((l1_s1048 (ite l1_s836 l1_s1047 l1_s1046)))-  (let ((l1_s1049 (xor l1_s288 l1_s1048)))-  (let ((l1_s1050 (ite l1_s868 l1_s1049 l1_s1048)))-  (let ((l1_s1051 (xor l1_s276 l1_s1050)))-  (let ((l1_s1052 (ite l1_s900 l1_s1051 l1_s1050)))-  (let ((l1_s1053 (xor l1_s266 l1_s1052)))-  (let ((l1_s1054 (ite l1_s932 l1_s1053 l1_s1052)))-  (let ((l1_s1055 (xor l1_s258 l1_s1054)))-  (let ((l1_s1056 (ite l1_s964 l1_s1055 l1_s1054)))-  (let ((l1_s1057 (xor l1_s252 l1_s1056)))-  (let ((l1_s1058 (ite l1_s996 l1_s1057 l1_s1056)))-  (let ((l1_s1059 (xor l1_s248 l1_s1058)))-  (let ((l1_s1060 (ite l1_s1028 l1_s1059 l1_s1058)))-  (let ((l1_s1061 (xor l1_s4 l1_s173)))-  (let ((l1_s1062 (ite l1_s580 l1_s1061 l1_s173)))-  (let ((l1_s1063 (xor l1_s486 l1_s1062)))-  (let ((l1_s1064 (ite l1_s612 l1_s1063 l1_s1062)))-  (let ((l1_s1065 (xor l1_s456 l1_s1064)))-  (let ((l1_s1066 (ite l1_s644 l1_s1065 l1_s1064)))-  (let ((l1_s1067 (xor l1_s428 l1_s1066)))-  (let ((l1_s1068 (ite l1_s676 l1_s1067 l1_s1066)))-  (let ((l1_s1069 (xor l1_s402 l1_s1068)))-  (let ((l1_s1070 (ite l1_s708 l1_s1069 l1_s1068)))-  (let ((l1_s1071 (xor l1_s378 l1_s1070)))-  (let ((l1_s1072 (ite l1_s740 l1_s1071 l1_s1070)))-  (let ((l1_s1073 (xor l1_s356 l1_s1072)))-  (let ((l1_s1074 (ite l1_s772 l1_s1073 l1_s1072)))-  (let ((l1_s1075 (xor l1_s336 l1_s1074)))-  (let ((l1_s1076 (ite l1_s804 l1_s1075 l1_s1074)))-  (let ((l1_s1077 (xor l1_s318 l1_s1076)))-  (let ((l1_s1078 (ite l1_s836 l1_s1077 l1_s1076)))-  (let ((l1_s1079 (xor l1_s302 l1_s1078)))-  (let ((l1_s1080 (ite l1_s868 l1_s1079 l1_s1078)))-  (let ((l1_s1081 (xor l1_s288 l1_s1080)))-  (let ((l1_s1082 (ite l1_s900 l1_s1081 l1_s1080)))-  (let ((l1_s1083 (xor l1_s276 l1_s1082)))-  (let ((l1_s1084 (ite l1_s932 l1_s1083 l1_s1082)))-  (let ((l1_s1085 (xor l1_s266 l1_s1084)))-  (let ((l1_s1086 (ite l1_s964 l1_s1085 l1_s1084)))-  (let ((l1_s1087 (xor l1_s258 l1_s1086)))-  (let ((l1_s1088 (ite l1_s996 l1_s1087 l1_s1086)))-  (let ((l1_s1089 (xor l1_s252 l1_s1088)))-  (let ((l1_s1090 (ite l1_s1028 l1_s1089 l1_s1088)))-  (let ((l1_s1091 (xor l1_s248 l1_s1090)))-  (let ((l1_s1092 (ite l1_s1060 l1_s1091 l1_s1090)))-  (let ((l1_s1093 (xor l1_s4 l1_s178)))-  (let ((l1_s1094 (ite l1_s612 l1_s1093 l1_s178)))-  (let ((l1_s1095 (xor l1_s486 l1_s1094)))-  (let ((l1_s1096 (ite l1_s644 l1_s1095 l1_s1094)))-  (let ((l1_s1097 (xor l1_s456 l1_s1096)))-  (let ((l1_s1098 (ite l1_s676 l1_s1097 l1_s1096)))-  (let ((l1_s1099 (xor l1_s428 l1_s1098)))-  (let ((l1_s1100 (ite l1_s708 l1_s1099 l1_s1098)))-  (let ((l1_s1101 (xor l1_s402 l1_s1100)))-  (let ((l1_s1102 (ite l1_s740 l1_s1101 l1_s1100)))-  (let ((l1_s1103 (xor l1_s378 l1_s1102)))-  (let ((l1_s1104 (ite l1_s772 l1_s1103 l1_s1102)))-  (let ((l1_s1105 (xor l1_s356 l1_s1104)))-  (let ((l1_s1106 (ite l1_s804 l1_s1105 l1_s1104)))-  (let ((l1_s1107 (xor l1_s336 l1_s1106)))-  (let ((l1_s1108 (ite l1_s836 l1_s1107 l1_s1106)))-  (let ((l1_s1109 (xor l1_s318 l1_s1108)))-  (let ((l1_s1110 (ite l1_s868 l1_s1109 l1_s1108)))-  (let ((l1_s1111 (xor l1_s302 l1_s1110)))-  (let ((l1_s1112 (ite l1_s900 l1_s1111 l1_s1110)))-  (let ((l1_s1113 (xor l1_s288 l1_s1112)))-  (let ((l1_s1114 (ite l1_s932 l1_s1113 l1_s1112)))-  (let ((l1_s1115 (xor l1_s276 l1_s1114)))-  (let ((l1_s1116 (ite l1_s964 l1_s1115 l1_s1114)))-  (let ((l1_s1117 (xor l1_s266 l1_s1116)))-  (let ((l1_s1118 (ite l1_s996 l1_s1117 l1_s1116)))-  (let ((l1_s1119 (xor l1_s258 l1_s1118)))-  (let ((l1_s1120 (ite l1_s1028 l1_s1119 l1_s1118)))-  (let ((l1_s1121 (xor l1_s252 l1_s1120)))-  (let ((l1_s1122 (ite l1_s1060 l1_s1121 l1_s1120)))-  (let ((l1_s1123 (xor l1_s248 l1_s1122)))-  (let ((l1_s1124 (ite l1_s1092 l1_s1123 l1_s1122)))-  (let ((l1_s1125 (xor l1_s4 l1_s183)))-  (let ((l1_s1126 (ite l1_s644 l1_s1125 l1_s183)))-  (let ((l1_s1127 (xor l1_s486 l1_s1126)))-  (let ((l1_s1128 (ite l1_s676 l1_s1127 l1_s1126)))-  (let ((l1_s1129 (xor l1_s456 l1_s1128)))-  (let ((l1_s1130 (ite l1_s708 l1_s1129 l1_s1128)))-  (let ((l1_s1131 (xor l1_s428 l1_s1130)))-  (let ((l1_s1132 (ite l1_s740 l1_s1131 l1_s1130)))-  (let ((l1_s1133 (xor l1_s402 l1_s1132)))-  (let ((l1_s1134 (ite l1_s772 l1_s1133 l1_s1132)))-  (let ((l1_s1135 (xor l1_s378 l1_s1134)))-  (let ((l1_s1136 (ite l1_s804 l1_s1135 l1_s1134)))-  (let ((l1_s1137 (xor l1_s356 l1_s1136)))-  (let ((l1_s1138 (ite l1_s836 l1_s1137 l1_s1136)))-  (let ((l1_s1139 (xor l1_s336 l1_s1138)))-  (let ((l1_s1140 (ite l1_s868 l1_s1139 l1_s1138)))-  (let ((l1_s1141 (xor l1_s318 l1_s1140)))-  (let ((l1_s1142 (ite l1_s900 l1_s1141 l1_s1140)))-  (let ((l1_s1143 (xor l1_s302 l1_s1142)))-  (let ((l1_s1144 (ite l1_s932 l1_s1143 l1_s1142)))-  (let ((l1_s1145 (xor l1_s288 l1_s1144)))-  (let ((l1_s1146 (ite l1_s964 l1_s1145 l1_s1144)))-  (let ((l1_s1147 (xor l1_s276 l1_s1146)))-  (let ((l1_s1148 (ite l1_s996 l1_s1147 l1_s1146)))-  (let ((l1_s1149 (xor l1_s266 l1_s1148)))-  (let ((l1_s1150 (ite l1_s1028 l1_s1149 l1_s1148)))-  (let ((l1_s1151 (xor l1_s258 l1_s1150)))-  (let ((l1_s1152 (ite l1_s1060 l1_s1151 l1_s1150)))-  (let ((l1_s1153 (xor l1_s252 l1_s1152)))-  (let ((l1_s1154 (ite l1_s1092 l1_s1153 l1_s1152)))-  (let ((l1_s1155 (xor l1_s248 l1_s1154)))-  (let ((l1_s1156 (ite l1_s1124 l1_s1155 l1_s1154)))-  (let ((l1_s1157 (xor l1_s4 l1_s188)))-  (let ((l1_s1158 (ite l1_s676 l1_s1157 l1_s188)))-  (let ((l1_s1159 (xor l1_s486 l1_s1158)))-  (let ((l1_s1160 (ite l1_s708 l1_s1159 l1_s1158)))-  (let ((l1_s1161 (xor l1_s456 l1_s1160)))-  (let ((l1_s1162 (ite l1_s740 l1_s1161 l1_s1160)))-  (let ((l1_s1163 (xor l1_s428 l1_s1162)))-  (let ((l1_s1164 (ite l1_s772 l1_s1163 l1_s1162)))-  (let ((l1_s1165 (xor l1_s402 l1_s1164)))-  (let ((l1_s1166 (ite l1_s804 l1_s1165 l1_s1164)))-  (let ((l1_s1167 (xor l1_s378 l1_s1166)))-  (let ((l1_s1168 (ite l1_s836 l1_s1167 l1_s1166)))-  (let ((l1_s1169 (xor l1_s356 l1_s1168)))-  (let ((l1_s1170 (ite l1_s868 l1_s1169 l1_s1168)))-  (let ((l1_s1171 (xor l1_s336 l1_s1170)))-  (let ((l1_s1172 (ite l1_s900 l1_s1171 l1_s1170)))-  (let ((l1_s1173 (xor l1_s318 l1_s1172)))-  (let ((l1_s1174 (ite l1_s932 l1_s1173 l1_s1172)))-  (let ((l1_s1175 (xor l1_s302 l1_s1174)))-  (let ((l1_s1176 (ite l1_s964 l1_s1175 l1_s1174)))-  (let ((l1_s1177 (xor l1_s288 l1_s1176)))-  (let ((l1_s1178 (ite l1_s996 l1_s1177 l1_s1176)))-  (let ((l1_s1179 (xor l1_s276 l1_s1178)))-  (let ((l1_s1180 (ite l1_s1028 l1_s1179 l1_s1178)))-  (let ((l1_s1181 (xor l1_s266 l1_s1180)))-  (let ((l1_s1182 (ite l1_s1060 l1_s1181 l1_s1180)))-  (let ((l1_s1183 (xor l1_s258 l1_s1182)))-  (let ((l1_s1184 (ite l1_s1092 l1_s1183 l1_s1182)))-  (let ((l1_s1185 (xor l1_s252 l1_s1184)))-  (let ((l1_s1186 (ite l1_s1124 l1_s1185 l1_s1184)))-  (let ((l1_s1187 (xor l1_s248 l1_s1186)))-  (let ((l1_s1188 (ite l1_s1156 l1_s1187 l1_s1186)))-  (let ((l1_s1189 (xor l1_s4 l1_s193)))-  (let ((l1_s1190 (ite l1_s708 l1_s1189 l1_s193)))-  (let ((l1_s1191 (xor l1_s486 l1_s1190)))-  (let ((l1_s1192 (ite l1_s740 l1_s1191 l1_s1190)))-  (let ((l1_s1193 (xor l1_s456 l1_s1192)))-  (let ((l1_s1194 (ite l1_s772 l1_s1193 l1_s1192)))-  (let ((l1_s1195 (xor l1_s428 l1_s1194)))-  (let ((l1_s1196 (ite l1_s804 l1_s1195 l1_s1194)))-  (let ((l1_s1197 (xor l1_s402 l1_s1196)))-  (let ((l1_s1198 (ite l1_s836 l1_s1197 l1_s1196)))-  (let ((l1_s1199 (xor l1_s378 l1_s1198)))-  (let ((l1_s1200 (ite l1_s868 l1_s1199 l1_s1198)))-  (let ((l1_s1201 (xor l1_s356 l1_s1200)))-  (let ((l1_s1202 (ite l1_s900 l1_s1201 l1_s1200)))-  (let ((l1_s1203 (xor l1_s336 l1_s1202)))-  (let ((l1_s1204 (ite l1_s932 l1_s1203 l1_s1202)))-  (let ((l1_s1205 (xor l1_s318 l1_s1204)))-  (let ((l1_s1206 (ite l1_s964 l1_s1205 l1_s1204)))-  (let ((l1_s1207 (xor l1_s302 l1_s1206)))-  (let ((l1_s1208 (ite l1_s996 l1_s1207 l1_s1206)))-  (let ((l1_s1209 (xor l1_s288 l1_s1208)))-  (let ((l1_s1210 (ite l1_s1028 l1_s1209 l1_s1208)))-  (let ((l1_s1211 (xor l1_s276 l1_s1210)))-  (let ((l1_s1212 (ite l1_s1060 l1_s1211 l1_s1210)))-  (let ((l1_s1213 (xor l1_s266 l1_s1212)))-  (let ((l1_s1214 (ite l1_s1092 l1_s1213 l1_s1212)))-  (let ((l1_s1215 (xor l1_s258 l1_s1214)))-  (let ((l1_s1216 (ite l1_s1124 l1_s1215 l1_s1214)))-  (let ((l1_s1217 (xor l1_s252 l1_s1216)))-  (let ((l1_s1218 (ite l1_s1156 l1_s1217 l1_s1216)))-  (let ((l1_s1219 (xor l1_s248 l1_s1218)))-  (let ((l1_s1220 (ite l1_s1188 l1_s1219 l1_s1218)))-  (let ((l1_s1221 (xor l1_s4 l1_s198)))-  (let ((l1_s1222 (ite l1_s740 l1_s1221 l1_s198)))-  (let ((l1_s1223 (xor l1_s486 l1_s1222)))-  (let ((l1_s1224 (ite l1_s772 l1_s1223 l1_s1222)))-  (let ((l1_s1225 (xor l1_s456 l1_s1224)))-  (let ((l1_s1226 (ite l1_s804 l1_s1225 l1_s1224)))-  (let ((l1_s1227 (xor l1_s428 l1_s1226)))-  (let ((l1_s1228 (ite l1_s836 l1_s1227 l1_s1226)))-  (let ((l1_s1229 (xor l1_s402 l1_s1228)))-  (let ((l1_s1230 (ite l1_s868 l1_s1229 l1_s1228)))-  (let ((l1_s1231 (xor l1_s378 l1_s1230)))-  (let ((l1_s1232 (ite l1_s900 l1_s1231 l1_s1230)))-  (let ((l1_s1233 (xor l1_s356 l1_s1232)))-  (let ((l1_s1234 (ite l1_s932 l1_s1233 l1_s1232)))-  (let ((l1_s1235 (xor l1_s336 l1_s1234)))-  (let ((l1_s1236 (ite l1_s964 l1_s1235 l1_s1234)))-  (let ((l1_s1237 (xor l1_s318 l1_s1236)))-  (let ((l1_s1238 (ite l1_s996 l1_s1237 l1_s1236)))-  (let ((l1_s1239 (xor l1_s302 l1_s1238)))-  (let ((l1_s1240 (ite l1_s1028 l1_s1239 l1_s1238)))-  (let ((l1_s1241 (xor l1_s288 l1_s1240)))-  (let ((l1_s1242 (ite l1_s1060 l1_s1241 l1_s1240)))-  (let ((l1_s1243 (xor l1_s276 l1_s1242)))-  (let ((l1_s1244 (ite l1_s1092 l1_s1243 l1_s1242)))-  (let ((l1_s1245 (xor l1_s266 l1_s1244)))-  (let ((l1_s1246 (ite l1_s1124 l1_s1245 l1_s1244)))-  (let ((l1_s1247 (xor l1_s258 l1_s1246)))-  (let ((l1_s1248 (ite l1_s1156 l1_s1247 l1_s1246)))-  (let ((l1_s1249 (xor l1_s252 l1_s1248)))-  (let ((l1_s1250 (ite l1_s1188 l1_s1249 l1_s1248)))-  (let ((l1_s1251 (xor l1_s248 l1_s1250)))-  (let ((l1_s1252 (ite l1_s1220 l1_s1251 l1_s1250)))-  (let ((l1_s1253 (xor l1_s4 l1_s203)))-  (let ((l1_s1254 (ite l1_s772 l1_s1253 l1_s203)))-  (let ((l1_s1255 (xor l1_s486 l1_s1254)))-  (let ((l1_s1256 (ite l1_s804 l1_s1255 l1_s1254)))-  (let ((l1_s1257 (xor l1_s456 l1_s1256)))-  (let ((l1_s1258 (ite l1_s836 l1_s1257 l1_s1256)))-  (let ((l1_s1259 (xor l1_s428 l1_s1258)))-  (let ((l1_s1260 (ite l1_s868 l1_s1259 l1_s1258)))-  (let ((l1_s1261 (xor l1_s402 l1_s1260)))-  (let ((l1_s1262 (ite l1_s900 l1_s1261 l1_s1260)))-  (let ((l1_s1263 (xor l1_s378 l1_s1262)))-  (let ((l1_s1264 (ite l1_s932 l1_s1263 l1_s1262)))-  (let ((l1_s1265 (xor l1_s356 l1_s1264)))-  (let ((l1_s1266 (ite l1_s964 l1_s1265 l1_s1264)))-  (let ((l1_s1267 (xor l1_s336 l1_s1266)))-  (let ((l1_s1268 (ite l1_s996 l1_s1267 l1_s1266)))-  (let ((l1_s1269 (xor l1_s318 l1_s1268)))-  (let ((l1_s1270 (ite l1_s1028 l1_s1269 l1_s1268)))-  (let ((l1_s1271 (xor l1_s302 l1_s1270)))-  (let ((l1_s1272 (ite l1_s1060 l1_s1271 l1_s1270)))-  (let ((l1_s1273 (xor l1_s288 l1_s1272)))-  (let ((l1_s1274 (ite l1_s1092 l1_s1273 l1_s1272)))-  (let ((l1_s1275 (xor l1_s276 l1_s1274)))-  (let ((l1_s1276 (ite l1_s1124 l1_s1275 l1_s1274)))-  (let ((l1_s1277 (xor l1_s266 l1_s1276)))-  (let ((l1_s1278 (ite l1_s1156 l1_s1277 l1_s1276)))-  (let ((l1_s1279 (xor l1_s258 l1_s1278)))-  (let ((l1_s1280 (ite l1_s1188 l1_s1279 l1_s1278)))-  (let ((l1_s1281 (xor l1_s252 l1_s1280)))-  (let ((l1_s1282 (ite l1_s1220 l1_s1281 l1_s1280)))-  (let ((l1_s1283 (xor l1_s248 l1_s1282)))-  (let ((l1_s1284 (ite l1_s1252 l1_s1283 l1_s1282)))-  (let ((l1_s1285 (xor l1_s4 l1_s208)))-  (let ((l1_s1286 (ite l1_s804 l1_s1285 l1_s208)))-  (let ((l1_s1287 (xor l1_s486 l1_s1286)))-  (let ((l1_s1288 (ite l1_s836 l1_s1287 l1_s1286)))-  (let ((l1_s1289 (xor l1_s456 l1_s1288)))-  (let ((l1_s1290 (ite l1_s868 l1_s1289 l1_s1288)))-  (let ((l1_s1291 (xor l1_s428 l1_s1290)))-  (let ((l1_s1292 (ite l1_s900 l1_s1291 l1_s1290)))-  (let ((l1_s1293 (xor l1_s402 l1_s1292)))-  (let ((l1_s1294 (ite l1_s932 l1_s1293 l1_s1292)))-  (let ((l1_s1295 (xor l1_s378 l1_s1294)))-  (let ((l1_s1296 (ite l1_s964 l1_s1295 l1_s1294)))-  (let ((l1_s1297 (xor l1_s356 l1_s1296)))-  (let ((l1_s1298 (ite l1_s996 l1_s1297 l1_s1296)))-  (let ((l1_s1299 (xor l1_s336 l1_s1298)))-  (let ((l1_s1300 (ite l1_s1028 l1_s1299 l1_s1298)))-  (let ((l1_s1301 (xor l1_s318 l1_s1300)))-  (let ((l1_s1302 (ite l1_s1060 l1_s1301 l1_s1300)))-  (let ((l1_s1303 (xor l1_s302 l1_s1302)))-  (let ((l1_s1304 (ite l1_s1092 l1_s1303 l1_s1302)))-  (let ((l1_s1305 (xor l1_s288 l1_s1304)))-  (let ((l1_s1306 (ite l1_s1124 l1_s1305 l1_s1304)))-  (let ((l1_s1307 (xor l1_s276 l1_s1306)))-  (let ((l1_s1308 (ite l1_s1156 l1_s1307 l1_s1306)))-  (let ((l1_s1309 (xor l1_s266 l1_s1308)))-  (let ((l1_s1310 (ite l1_s1188 l1_s1309 l1_s1308)))-  (let ((l1_s1311 (xor l1_s258 l1_s1310)))-  (let ((l1_s1312 (ite l1_s1220 l1_s1311 l1_s1310)))-  (let ((l1_s1313 (xor l1_s252 l1_s1312)))-  (let ((l1_s1314 (ite l1_s1252 l1_s1313 l1_s1312)))-  (let ((l1_s1315 (xor l1_s248 l1_s1314)))-  (let ((l1_s1316 (ite l1_s1284 l1_s1315 l1_s1314)))-  (let ((l1_s1317 (xor l1_s4 l1_s213)))-  (let ((l1_s1318 (ite l1_s836 l1_s1317 l1_s213)))-  (let ((l1_s1319 (xor l1_s486 l1_s1318)))-  (let ((l1_s1320 (ite l1_s868 l1_s1319 l1_s1318)))-  (let ((l1_s1321 (xor l1_s456 l1_s1320)))-  (let ((l1_s1322 (ite l1_s900 l1_s1321 l1_s1320)))-  (let ((l1_s1323 (xor l1_s428 l1_s1322)))-  (let ((l1_s1324 (ite l1_s932 l1_s1323 l1_s1322)))-  (let ((l1_s1325 (xor l1_s402 l1_s1324)))-  (let ((l1_s1326 (ite l1_s964 l1_s1325 l1_s1324)))-  (let ((l1_s1327 (xor l1_s378 l1_s1326)))-  (let ((l1_s1328 (ite l1_s996 l1_s1327 l1_s1326)))-  (let ((l1_s1329 (xor l1_s356 l1_s1328)))-  (let ((l1_s1330 (ite l1_s1028 l1_s1329 l1_s1328)))-  (let ((l1_s1331 (xor l1_s336 l1_s1330)))-  (let ((l1_s1332 (ite l1_s1060 l1_s1331 l1_s1330)))-  (let ((l1_s1333 (xor l1_s318 l1_s1332)))-  (let ((l1_s1334 (ite l1_s1092 l1_s1333 l1_s1332)))-  (let ((l1_s1335 (xor l1_s302 l1_s1334)))-  (let ((l1_s1336 (ite l1_s1124 l1_s1335 l1_s1334)))-  (let ((l1_s1337 (xor l1_s288 l1_s1336)))-  (let ((l1_s1338 (ite l1_s1156 l1_s1337 l1_s1336)))-  (let ((l1_s1339 (xor l1_s276 l1_s1338)))-  (let ((l1_s1340 (ite l1_s1188 l1_s1339 l1_s1338)))-  (let ((l1_s1341 (xor l1_s266 l1_s1340)))-  (let ((l1_s1342 (ite l1_s1220 l1_s1341 l1_s1340)))-  (let ((l1_s1343 (xor l1_s258 l1_s1342)))-  (let ((l1_s1344 (ite l1_s1252 l1_s1343 l1_s1342)))-  (let ((l1_s1345 (xor l1_s252 l1_s1344)))-  (let ((l1_s1346 (ite l1_s1284 l1_s1345 l1_s1344)))-  (let ((l1_s1347 (xor l1_s248 l1_s1346)))-  (let ((l1_s1348 (ite l1_s1316 l1_s1347 l1_s1346)))-  (let ((l1_s1349 (xor l1_s4 l1_s218)))-  (let ((l1_s1350 (ite l1_s868 l1_s1349 l1_s218)))-  (let ((l1_s1351 (xor l1_s486 l1_s1350)))-  (let ((l1_s1352 (ite l1_s900 l1_s1351 l1_s1350)))-  (let ((l1_s1353 (xor l1_s456 l1_s1352)))-  (let ((l1_s1354 (ite l1_s932 l1_s1353 l1_s1352)))-  (let ((l1_s1355 (xor l1_s428 l1_s1354)))-  (let ((l1_s1356 (ite l1_s964 l1_s1355 l1_s1354)))-  (let ((l1_s1357 (xor l1_s402 l1_s1356)))-  (let ((l1_s1358 (ite l1_s996 l1_s1357 l1_s1356)))-  (let ((l1_s1359 (xor l1_s378 l1_s1358)))-  (let ((l1_s1360 (ite l1_s1028 l1_s1359 l1_s1358)))-  (let ((l1_s1361 (xor l1_s356 l1_s1360)))-  (let ((l1_s1362 (ite l1_s1060 l1_s1361 l1_s1360)))-  (let ((l1_s1363 (xor l1_s336 l1_s1362)))-  (let ((l1_s1364 (ite l1_s1092 l1_s1363 l1_s1362)))-  (let ((l1_s1365 (xor l1_s318 l1_s1364)))-  (let ((l1_s1366 (ite l1_s1124 l1_s1365 l1_s1364)))-  (let ((l1_s1367 (xor l1_s302 l1_s1366)))-  (let ((l1_s1368 (ite l1_s1156 l1_s1367 l1_s1366)))-  (let ((l1_s1369 (xor l1_s288 l1_s1368)))-  (let ((l1_s1370 (ite l1_s1188 l1_s1369 l1_s1368)))-  (let ((l1_s1371 (xor l1_s276 l1_s1370)))-  (let ((l1_s1372 (ite l1_s1220 l1_s1371 l1_s1370)))-  (let ((l1_s1373 (xor l1_s266 l1_s1372)))-  (let ((l1_s1374 (ite l1_s1252 l1_s1373 l1_s1372)))-  (let ((l1_s1375 (xor l1_s258 l1_s1374)))-  (let ((l1_s1376 (ite l1_s1284 l1_s1375 l1_s1374)))-  (let ((l1_s1377 (xor l1_s252 l1_s1376)))-  (let ((l1_s1378 (ite l1_s1316 l1_s1377 l1_s1376)))-  (let ((l1_s1379 (xor l1_s248 l1_s1378)))-  (let ((l1_s1380 (ite l1_s1348 l1_s1379 l1_s1378)))-  (let ((l1_s1381 (xor l1_s4 l1_s223)))-  (let ((l1_s1382 (ite l1_s900 l1_s1381 l1_s223)))-  (let ((l1_s1383 (xor l1_s486 l1_s1382)))-  (let ((l1_s1384 (ite l1_s932 l1_s1383 l1_s1382)))-  (let ((l1_s1385 (xor l1_s456 l1_s1384)))-  (let ((l1_s1386 (ite l1_s964 l1_s1385 l1_s1384)))-  (let ((l1_s1387 (xor l1_s428 l1_s1386)))-  (let ((l1_s1388 (ite l1_s996 l1_s1387 l1_s1386)))-  (let ((l1_s1389 (xor l1_s402 l1_s1388)))-  (let ((l1_s1390 (ite l1_s1028 l1_s1389 l1_s1388)))-  (let ((l1_s1391 (xor l1_s378 l1_s1390)))-  (let ((l1_s1392 (ite l1_s1060 l1_s1391 l1_s1390)))-  (let ((l1_s1393 (xor l1_s356 l1_s1392)))-  (let ((l1_s1394 (ite l1_s1092 l1_s1393 l1_s1392)))-  (let ((l1_s1395 (xor l1_s336 l1_s1394)))-  (let ((l1_s1396 (ite l1_s1124 l1_s1395 l1_s1394)))-  (let ((l1_s1397 (xor l1_s318 l1_s1396)))-  (let ((l1_s1398 (ite l1_s1156 l1_s1397 l1_s1396)))-  (let ((l1_s1399 (xor l1_s302 l1_s1398)))-  (let ((l1_s1400 (ite l1_s1188 l1_s1399 l1_s1398)))-  (let ((l1_s1401 (xor l1_s288 l1_s1400)))-  (let ((l1_s1402 (ite l1_s1220 l1_s1401 l1_s1400)))-  (let ((l1_s1403 (xor l1_s276 l1_s1402)))-  (let ((l1_s1404 (ite l1_s1252 l1_s1403 l1_s1402)))-  (let ((l1_s1405 (xor l1_s266 l1_s1404)))-  (let ((l1_s1406 (ite l1_s1284 l1_s1405 l1_s1404)))-  (let ((l1_s1407 (xor l1_s258 l1_s1406)))-  (let ((l1_s1408 (ite l1_s1316 l1_s1407 l1_s1406)))-  (let ((l1_s1409 (xor l1_s252 l1_s1408)))-  (let ((l1_s1410 (ite l1_s1348 l1_s1409 l1_s1408)))-  (let ((l1_s1411 (xor l1_s248 l1_s1410)))-  (let ((l1_s1412 (ite l1_s1380 l1_s1411 l1_s1410)))-  (let ((l1_s1413 (xor l1_s4 l1_s228)))-  (let ((l1_s1414 (ite l1_s932 l1_s1413 l1_s228)))-  (let ((l1_s1415 (xor l1_s486 l1_s1414)))-  (let ((l1_s1416 (ite l1_s964 l1_s1415 l1_s1414)))-  (let ((l1_s1417 (xor l1_s456 l1_s1416)))-  (let ((l1_s1418 (ite l1_s996 l1_s1417 l1_s1416)))-  (let ((l1_s1419 (xor l1_s428 l1_s1418)))-  (let ((l1_s1420 (ite l1_s1028 l1_s1419 l1_s1418)))-  (let ((l1_s1421 (xor l1_s402 l1_s1420)))-  (let ((l1_s1422 (ite l1_s1060 l1_s1421 l1_s1420)))-  (let ((l1_s1423 (xor l1_s378 l1_s1422)))-  (let ((l1_s1424 (ite l1_s1092 l1_s1423 l1_s1422)))-  (let ((l1_s1425 (xor l1_s356 l1_s1424)))-  (let ((l1_s1426 (ite l1_s1124 l1_s1425 l1_s1424)))-  (let ((l1_s1427 (xor l1_s336 l1_s1426)))-  (let ((l1_s1428 (ite l1_s1156 l1_s1427 l1_s1426)))-  (let ((l1_s1429 (xor l1_s318 l1_s1428)))-  (let ((l1_s1430 (ite l1_s1188 l1_s1429 l1_s1428)))-  (let ((l1_s1431 (xor l1_s302 l1_s1430)))-  (let ((l1_s1432 (ite l1_s1220 l1_s1431 l1_s1430)))-  (let ((l1_s1433 (xor l1_s288 l1_s1432)))-  (let ((l1_s1434 (ite l1_s1252 l1_s1433 l1_s1432)))-  (let ((l1_s1435 (xor l1_s276 l1_s1434)))-  (let ((l1_s1436 (ite l1_s1284 l1_s1435 l1_s1434)))-  (let ((l1_s1437 (xor l1_s266 l1_s1436)))-  (let ((l1_s1438 (ite l1_s1316 l1_s1437 l1_s1436)))-  (let ((l1_s1439 (xor l1_s258 l1_s1438)))-  (let ((l1_s1440 (ite l1_s1348 l1_s1439 l1_s1438)))-  (let ((l1_s1441 (xor l1_s252 l1_s1440)))-  (let ((l1_s1442 (ite l1_s1380 l1_s1441 l1_s1440)))-  (let ((l1_s1443 (xor l1_s248 l1_s1442)))-  (let ((l1_s1444 (ite l1_s1412 l1_s1443 l1_s1442)))-  (let ((l1_s1445 (xor l1_s4 l1_s233)))-  (let ((l1_s1446 (ite l1_s964 l1_s1445 l1_s233)))-  (let ((l1_s1447 (xor l1_s486 l1_s1446)))-  (let ((l1_s1448 (ite l1_s996 l1_s1447 l1_s1446)))-  (let ((l1_s1449 (xor l1_s456 l1_s1448)))-  (let ((l1_s1450 (ite l1_s1028 l1_s1449 l1_s1448)))-  (let ((l1_s1451 (xor l1_s428 l1_s1450)))-  (let ((l1_s1452 (ite l1_s1060 l1_s1451 l1_s1450)))-  (let ((l1_s1453 (xor l1_s402 l1_s1452)))-  (let ((l1_s1454 (ite l1_s1092 l1_s1453 l1_s1452)))-  (let ((l1_s1455 (xor l1_s378 l1_s1454)))-  (let ((l1_s1456 (ite l1_s1124 l1_s1455 l1_s1454)))-  (let ((l1_s1457 (xor l1_s356 l1_s1456)))-  (let ((l1_s1458 (ite l1_s1156 l1_s1457 l1_s1456)))-  (let ((l1_s1459 (xor l1_s336 l1_s1458)))-  (let ((l1_s1460 (ite l1_s1188 l1_s1459 l1_s1458)))-  (let ((l1_s1461 (xor l1_s318 l1_s1460)))-  (let ((l1_s1462 (ite l1_s1220 l1_s1461 l1_s1460)))-  (let ((l1_s1463 (xor l1_s302 l1_s1462)))-  (let ((l1_s1464 (ite l1_s1252 l1_s1463 l1_s1462)))-  (let ((l1_s1465 (xor l1_s288 l1_s1464)))-  (let ((l1_s1466 (ite l1_s1284 l1_s1465 l1_s1464)))-  (let ((l1_s1467 (xor l1_s276 l1_s1466)))-  (let ((l1_s1468 (ite l1_s1316 l1_s1467 l1_s1466)))-  (let ((l1_s1469 (xor l1_s266 l1_s1468)))-  (let ((l1_s1470 (ite l1_s1348 l1_s1469 l1_s1468)))-  (let ((l1_s1471 (xor l1_s258 l1_s1470)))-  (let ((l1_s1472 (ite l1_s1380 l1_s1471 l1_s1470)))-  (let ((l1_s1473 (xor l1_s252 l1_s1472)))-  (let ((l1_s1474 (ite l1_s1412 l1_s1473 l1_s1472)))-  (let ((l1_s1475 (xor l1_s248 l1_s1474)))-  (let ((l1_s1476 (ite l1_s1444 l1_s1475 l1_s1474)))-  (let ((l1_s1477 (xor l1_s4 l1_s238)))-  (let ((l1_s1478 (ite l1_s996 l1_s1477 l1_s238)))-  (let ((l1_s1479 (xor l1_s486 l1_s1478)))-  (let ((l1_s1480 (ite l1_s1028 l1_s1479 l1_s1478)))-  (let ((l1_s1481 (xor l1_s456 l1_s1480)))-  (let ((l1_s1482 (ite l1_s1060 l1_s1481 l1_s1480)))-  (let ((l1_s1483 (xor l1_s428 l1_s1482)))-  (let ((l1_s1484 (ite l1_s1092 l1_s1483 l1_s1482)))-  (let ((l1_s1485 (xor l1_s402 l1_s1484)))-  (let ((l1_s1486 (ite l1_s1124 l1_s1485 l1_s1484)))-  (let ((l1_s1487 (xor l1_s378 l1_s1486)))-  (let ((l1_s1488 (ite l1_s1156 l1_s1487 l1_s1486)))-  (let ((l1_s1489 (xor l1_s356 l1_s1488)))-  (let ((l1_s1490 (ite l1_s1188 l1_s1489 l1_s1488)))-  (let ((l1_s1491 (xor l1_s336 l1_s1490)))-  (let ((l1_s1492 (ite l1_s1220 l1_s1491 l1_s1490)))-  (let ((l1_s1493 (xor l1_s318 l1_s1492)))-  (let ((l1_s1494 (ite l1_s1252 l1_s1493 l1_s1492)))-  (let ((l1_s1495 (xor l1_s302 l1_s1494)))-  (let ((l1_s1496 (ite l1_s1284 l1_s1495 l1_s1494)))-  (let ((l1_s1497 (xor l1_s288 l1_s1496)))-  (let ((l1_s1498 (ite l1_s1316 l1_s1497 l1_s1496)))-  (let ((l1_s1499 (xor l1_s276 l1_s1498)))-  (let ((l1_s1500 (ite l1_s1348 l1_s1499 l1_s1498)))-  (let ((l1_s1501 (xor l1_s266 l1_s1500)))-  (let ((l1_s1502 (ite l1_s1380 l1_s1501 l1_s1500)))-  (let ((l1_s1503 (xor l1_s258 l1_s1502)))-  (let ((l1_s1504 (ite l1_s1412 l1_s1503 l1_s1502)))-  (let ((l1_s1505 (xor l1_s252 l1_s1504)))-  (let ((l1_s1506 (ite l1_s1444 l1_s1505 l1_s1504)))-  (let ((l1_s1507 (xor l1_s248 l1_s1506)))-  (let ((l1_s1508 (ite l1_s1476 l1_s1507 l1_s1506)))-  (let ((l1_s1509 (xor l1_s4 l1_s243)))-  (let ((l1_s1510 (ite l1_s1028 l1_s1509 l1_s243)))-  (let ((l1_s1511 (xor l1_s486 l1_s1510)))-  (let ((l1_s1512 (ite l1_s1060 l1_s1511 l1_s1510)))-  (let ((l1_s1513 (xor l1_s456 l1_s1512)))-  (let ((l1_s1514 (ite l1_s1092 l1_s1513 l1_s1512)))-  (let ((l1_s1515 (xor l1_s428 l1_s1514)))-  (let ((l1_s1516 (ite l1_s1124 l1_s1515 l1_s1514)))-  (let ((l1_s1517 (xor l1_s402 l1_s1516)))-  (let ((l1_s1518 (ite l1_s1156 l1_s1517 l1_s1516)))-  (let ((l1_s1519 (xor l1_s378 l1_s1518)))-  (let ((l1_s1520 (ite l1_s1188 l1_s1519 l1_s1518)))-  (let ((l1_s1521 (xor l1_s356 l1_s1520)))-  (let ((l1_s1522 (ite l1_s1220 l1_s1521 l1_s1520)))-  (let ((l1_s1523 (xor l1_s336 l1_s1522)))-  (let ((l1_s1524 (ite l1_s1252 l1_s1523 l1_s1522)))-  (let ((l1_s1525 (xor l1_s318 l1_s1524)))-  (let ((l1_s1526 (ite l1_s1284 l1_s1525 l1_s1524)))-  (let ((l1_s1527 (xor l1_s302 l1_s1526)))-  (let ((l1_s1528 (ite l1_s1316 l1_s1527 l1_s1526)))-  (let ((l1_s1529 (xor l1_s288 l1_s1528)))-  (let ((l1_s1530 (ite l1_s1348 l1_s1529 l1_s1528)))-  (let ((l1_s1531 (xor l1_s276 l1_s1530)))-  (let ((l1_s1532 (ite l1_s1380 l1_s1531 l1_s1530)))-  (let ((l1_s1533 (xor l1_s266 l1_s1532)))-  (let ((l1_s1534 (ite l1_s1412 l1_s1533 l1_s1532)))-  (let ((l1_s1535 (xor l1_s258 l1_s1534)))-  (let ((l1_s1536 (ite l1_s1444 l1_s1535 l1_s1534)))-  (let ((l1_s1537 (xor l1_s252 l1_s1536)))-  (let ((l1_s1538 (ite l1_s1476 l1_s1537 l1_s1536)))-  (let ((l1_s1539 (xor l1_s248 l1_s1538)))-  (let ((l1_s1540 (ite l1_s1508 l1_s1539 l1_s1538)))-  (let ((l1_s1541 (and l1_s4 l1_s1060)))-  (let ((l1_s1542 (xor l1_s486 l1_s1541)))-  (let ((l1_s1543 (ite l1_s1092 l1_s1542 l1_s1541)))-  (let ((l1_s1544 (xor l1_s456 l1_s1543)))-  (let ((l1_s1545 (ite l1_s1124 l1_s1544 l1_s1543)))-  (let ((l1_s1546 (xor l1_s428 l1_s1545)))-  (let ((l1_s1547 (ite l1_s1156 l1_s1546 l1_s1545)))-  (let ((l1_s1548 (xor l1_s402 l1_s1547)))-  (let ((l1_s1549 (ite l1_s1188 l1_s1548 l1_s1547)))-  (let ((l1_s1550 (xor l1_s378 l1_s1549)))-  (let ((l1_s1551 (ite l1_s1220 l1_s1550 l1_s1549)))-  (let ((l1_s1552 (xor l1_s356 l1_s1551)))-  (let ((l1_s1553 (ite l1_s1252 l1_s1552 l1_s1551)))-  (let ((l1_s1554 (xor l1_s336 l1_s1553)))-  (let ((l1_s1555 (ite l1_s1284 l1_s1554 l1_s1553)))-  (let ((l1_s1556 (xor l1_s318 l1_s1555)))-  (let ((l1_s1557 (ite l1_s1316 l1_s1556 l1_s1555)))-  (let ((l1_s1558 (xor l1_s302 l1_s1557)))-  (let ((l1_s1559 (ite l1_s1348 l1_s1558 l1_s1557)))-  (let ((l1_s1560 (xor l1_s288 l1_s1559)))-  (let ((l1_s1561 (ite l1_s1380 l1_s1560 l1_s1559)))-  (let ((l1_s1562 (xor l1_s276 l1_s1561)))-  (let ((l1_s1563 (ite l1_s1412 l1_s1562 l1_s1561)))-  (let ((l1_s1564 (xor l1_s266 l1_s1563)))-  (let ((l1_s1565 (ite l1_s1444 l1_s1564 l1_s1563)))-  (let ((l1_s1566 (xor l1_s258 l1_s1565)))-  (let ((l1_s1567 (ite l1_s1476 l1_s1566 l1_s1565)))-  (let ((l1_s1568 (xor l1_s252 l1_s1567)))-  (let ((l1_s1569 (ite l1_s1508 l1_s1568 l1_s1567)))-  (let ((l1_s1570 (xor l1_s248 l1_s1569)))-  (let ((l1_s1571 (ite l1_s1540 l1_s1570 l1_s1569)))-  (let ((l1_s1572 (xor l1_s15 l1_s248)))-  (let ((l1_s1573 (ite l1_s9 l1_s1572 l1_s15)))-  (let ((l1_s1574 (xor l1_s20 l1_s252)))-  (let ((l1_s1575 (ite l1_s9 l1_s1574 l1_s20)))-  (let ((l1_s1576 (xor l1_s248 l1_s1575)))-  (let ((l1_s1577 (ite l1_s1573 l1_s1576 l1_s1575)))-  (let ((l1_s1578 (xor l1_s25 l1_s258)))-  (let ((l1_s1579 (ite l1_s9 l1_s1578 l1_s25)))-  (let ((l1_s1580 (xor l1_s252 l1_s1579)))-  (let ((l1_s1581 (ite l1_s1573 l1_s1580 l1_s1579)))-  (let ((l1_s1582 (xor l1_s248 l1_s1581)))-  (let ((l1_s1583 (ite l1_s1577 l1_s1582 l1_s1581)))-  (let ((l1_s1584 (xor l1_s30 l1_s266)))-  (let ((l1_s1585 (ite l1_s9 l1_s1584 l1_s30)))-  (let ((l1_s1586 (xor l1_s258 l1_s1585)))-  (let ((l1_s1587 (ite l1_s1573 l1_s1586 l1_s1585)))-  (let ((l1_s1588 (xor l1_s252 l1_s1587)))-  (let ((l1_s1589 (ite l1_s1577 l1_s1588 l1_s1587)))-  (let ((l1_s1590 (xor l1_s248 l1_s1589)))-  (let ((l1_s1591 (ite l1_s1583 l1_s1590 l1_s1589)))-  (let ((l1_s1592 (xor l1_s35 l1_s276)))-  (let ((l1_s1593 (ite l1_s9 l1_s1592 l1_s35)))-  (let ((l1_s1594 (xor l1_s266 l1_s1593)))-  (let ((l1_s1595 (ite l1_s1573 l1_s1594 l1_s1593)))-  (let ((l1_s1596 (xor l1_s258 l1_s1595)))-  (let ((l1_s1597 (ite l1_s1577 l1_s1596 l1_s1595)))-  (let ((l1_s1598 (xor l1_s252 l1_s1597)))-  (let ((l1_s1599 (ite l1_s1583 l1_s1598 l1_s1597)))-  (let ((l1_s1600 (xor l1_s248 l1_s1599)))-  (let ((l1_s1601 (ite l1_s1591 l1_s1600 l1_s1599)))-  (let ((l1_s1602 (xor l1_s40 l1_s288)))-  (let ((l1_s1603 (ite l1_s9 l1_s1602 l1_s40)))-  (let ((l1_s1604 (xor l1_s276 l1_s1603)))-  (let ((l1_s1605 (ite l1_s1573 l1_s1604 l1_s1603)))-  (let ((l1_s1606 (xor l1_s266 l1_s1605)))-  (let ((l1_s1607 (ite l1_s1577 l1_s1606 l1_s1605)))-  (let ((l1_s1608 (xor l1_s258 l1_s1607)))-  (let ((l1_s1609 (ite l1_s1583 l1_s1608 l1_s1607)))-  (let ((l1_s1610 (xor l1_s252 l1_s1609)))-  (let ((l1_s1611 (ite l1_s1591 l1_s1610 l1_s1609)))-  (let ((l1_s1612 (xor l1_s248 l1_s1611)))-  (let ((l1_s1613 (ite l1_s1601 l1_s1612 l1_s1611)))-  (let ((l1_s1614 (xor l1_s45 l1_s302)))-  (let ((l1_s1615 (ite l1_s9 l1_s1614 l1_s45)))-  (let ((l1_s1616 (xor l1_s288 l1_s1615)))-  (let ((l1_s1617 (ite l1_s1573 l1_s1616 l1_s1615)))-  (let ((l1_s1618 (xor l1_s276 l1_s1617)))-  (let ((l1_s1619 (ite l1_s1577 l1_s1618 l1_s1617)))-  (let ((l1_s1620 (xor l1_s266 l1_s1619)))-  (let ((l1_s1621 (ite l1_s1583 l1_s1620 l1_s1619)))-  (let ((l1_s1622 (xor l1_s258 l1_s1621)))-  (let ((l1_s1623 (ite l1_s1591 l1_s1622 l1_s1621)))-  (let ((l1_s1624 (xor l1_s252 l1_s1623)))-  (let ((l1_s1625 (ite l1_s1601 l1_s1624 l1_s1623)))-  (let ((l1_s1626 (xor l1_s248 l1_s1625)))-  (let ((l1_s1627 (ite l1_s1613 l1_s1626 l1_s1625)))-  (let ((l1_s1628 (xor l1_s50 l1_s318)))-  (let ((l1_s1629 (ite l1_s9 l1_s1628 l1_s50)))-  (let ((l1_s1630 (xor l1_s302 l1_s1629)))-  (let ((l1_s1631 (ite l1_s1573 l1_s1630 l1_s1629)))-  (let ((l1_s1632 (xor l1_s288 l1_s1631)))-  (let ((l1_s1633 (ite l1_s1577 l1_s1632 l1_s1631)))-  (let ((l1_s1634 (xor l1_s276 l1_s1633)))-  (let ((l1_s1635 (ite l1_s1583 l1_s1634 l1_s1633)))-  (let ((l1_s1636 (xor l1_s266 l1_s1635)))-  (let ((l1_s1637 (ite l1_s1591 l1_s1636 l1_s1635)))-  (let ((l1_s1638 (xor l1_s258 l1_s1637)))-  (let ((l1_s1639 (ite l1_s1601 l1_s1638 l1_s1637)))-  (let ((l1_s1640 (xor l1_s252 l1_s1639)))-  (let ((l1_s1641 (ite l1_s1613 l1_s1640 l1_s1639)))-  (let ((l1_s1642 (xor l1_s248 l1_s1641)))-  (let ((l1_s1643 (ite l1_s1627 l1_s1642 l1_s1641)))-  (let ((l1_s1644 (xor l1_s55 l1_s336)))-  (let ((l1_s1645 (ite l1_s9 l1_s1644 l1_s55)))-  (let ((l1_s1646 (xor l1_s318 l1_s1645)))-  (let ((l1_s1647 (ite l1_s1573 l1_s1646 l1_s1645)))-  (let ((l1_s1648 (xor l1_s302 l1_s1647)))-  (let ((l1_s1649 (ite l1_s1577 l1_s1648 l1_s1647)))-  (let ((l1_s1650 (xor l1_s288 l1_s1649)))-  (let ((l1_s1651 (ite l1_s1583 l1_s1650 l1_s1649)))-  (let ((l1_s1652 (xor l1_s276 l1_s1651)))-  (let ((l1_s1653 (ite l1_s1591 l1_s1652 l1_s1651)))-  (let ((l1_s1654 (xor l1_s266 l1_s1653)))-  (let ((l1_s1655 (ite l1_s1601 l1_s1654 l1_s1653)))-  (let ((l1_s1656 (xor l1_s258 l1_s1655)))-  (let ((l1_s1657 (ite l1_s1613 l1_s1656 l1_s1655)))-  (let ((l1_s1658 (xor l1_s252 l1_s1657)))-  (let ((l1_s1659 (ite l1_s1627 l1_s1658 l1_s1657)))-  (let ((l1_s1660 (xor l1_s248 l1_s1659)))-  (let ((l1_s1661 (ite l1_s1643 l1_s1660 l1_s1659)))-  (let ((l1_s1662 (xor l1_s60 l1_s356)))-  (let ((l1_s1663 (ite l1_s9 l1_s1662 l1_s60)))-  (let ((l1_s1664 (xor l1_s336 l1_s1663)))-  (let ((l1_s1665 (ite l1_s1573 l1_s1664 l1_s1663)))-  (let ((l1_s1666 (xor l1_s318 l1_s1665)))-  (let ((l1_s1667 (ite l1_s1577 l1_s1666 l1_s1665)))-  (let ((l1_s1668 (xor l1_s302 l1_s1667)))-  (let ((l1_s1669 (ite l1_s1583 l1_s1668 l1_s1667)))-  (let ((l1_s1670 (xor l1_s288 l1_s1669)))-  (let ((l1_s1671 (ite l1_s1591 l1_s1670 l1_s1669)))-  (let ((l1_s1672 (xor l1_s276 l1_s1671)))-  (let ((l1_s1673 (ite l1_s1601 l1_s1672 l1_s1671)))-  (let ((l1_s1674 (xor l1_s266 l1_s1673)))-  (let ((l1_s1675 (ite l1_s1613 l1_s1674 l1_s1673)))-  (let ((l1_s1676 (xor l1_s258 l1_s1675)))-  (let ((l1_s1677 (ite l1_s1627 l1_s1676 l1_s1675)))-  (let ((l1_s1678 (xor l1_s252 l1_s1677)))-  (let ((l1_s1679 (ite l1_s1643 l1_s1678 l1_s1677)))-  (let ((l1_s1680 (xor l1_s248 l1_s1679)))-  (let ((l1_s1681 (ite l1_s1661 l1_s1680 l1_s1679)))-  (let ((l1_s1682 (xor l1_s65 l1_s378)))-  (let ((l1_s1683 (ite l1_s9 l1_s1682 l1_s65)))-  (let ((l1_s1684 (xor l1_s356 l1_s1683)))-  (let ((l1_s1685 (ite l1_s1573 l1_s1684 l1_s1683)))-  (let ((l1_s1686 (xor l1_s336 l1_s1685)))-  (let ((l1_s1687 (ite l1_s1577 l1_s1686 l1_s1685)))-  (let ((l1_s1688 (xor l1_s318 l1_s1687)))-  (let ((l1_s1689 (ite l1_s1583 l1_s1688 l1_s1687)))-  (let ((l1_s1690 (xor l1_s302 l1_s1689)))-  (let ((l1_s1691 (ite l1_s1591 l1_s1690 l1_s1689)))-  (let ((l1_s1692 (xor l1_s288 l1_s1691)))-  (let ((l1_s1693 (ite l1_s1601 l1_s1692 l1_s1691)))-  (let ((l1_s1694 (xor l1_s276 l1_s1693)))-  (let ((l1_s1695 (ite l1_s1613 l1_s1694 l1_s1693)))-  (let ((l1_s1696 (xor l1_s266 l1_s1695)))-  (let ((l1_s1697 (ite l1_s1627 l1_s1696 l1_s1695)))-  (let ((l1_s1698 (xor l1_s258 l1_s1697)))-  (let ((l1_s1699 (ite l1_s1643 l1_s1698 l1_s1697)))-  (let ((l1_s1700 (xor l1_s252 l1_s1699)))-  (let ((l1_s1701 (ite l1_s1661 l1_s1700 l1_s1699)))-  (let ((l1_s1702 (xor l1_s248 l1_s1701)))-  (let ((l1_s1703 (ite l1_s1681 l1_s1702 l1_s1701)))-  (let ((l1_s1704 (xor l1_s70 l1_s402)))-  (let ((l1_s1705 (ite l1_s9 l1_s1704 l1_s70)))-  (let ((l1_s1706 (xor l1_s378 l1_s1705)))-  (let ((l1_s1707 (ite l1_s1573 l1_s1706 l1_s1705)))-  (let ((l1_s1708 (xor l1_s356 l1_s1707)))-  (let ((l1_s1709 (ite l1_s1577 l1_s1708 l1_s1707)))-  (let ((l1_s1710 (xor l1_s336 l1_s1709)))-  (let ((l1_s1711 (ite l1_s1583 l1_s1710 l1_s1709)))-  (let ((l1_s1712 (xor l1_s318 l1_s1711)))-  (let ((l1_s1713 (ite l1_s1591 l1_s1712 l1_s1711)))-  (let ((l1_s1714 (xor l1_s302 l1_s1713)))-  (let ((l1_s1715 (ite l1_s1601 l1_s1714 l1_s1713)))-  (let ((l1_s1716 (xor l1_s288 l1_s1715)))-  (let ((l1_s1717 (ite l1_s1613 l1_s1716 l1_s1715)))-  (let ((l1_s1718 (xor l1_s276 l1_s1717)))-  (let ((l1_s1719 (ite l1_s1627 l1_s1718 l1_s1717)))-  (let ((l1_s1720 (xor l1_s266 l1_s1719)))-  (let ((l1_s1721 (ite l1_s1643 l1_s1720 l1_s1719)))-  (let ((l1_s1722 (xor l1_s258 l1_s1721)))-  (let ((l1_s1723 (ite l1_s1661 l1_s1722 l1_s1721)))-  (let ((l1_s1724 (xor l1_s252 l1_s1723)))-  (let ((l1_s1725 (ite l1_s1681 l1_s1724 l1_s1723)))-  (let ((l1_s1726 (xor l1_s248 l1_s1725)))-  (let ((l1_s1727 (ite l1_s1703 l1_s1726 l1_s1725)))-  (let ((l1_s1728 (xor l1_s75 l1_s428)))-  (let ((l1_s1729 (ite l1_s9 l1_s1728 l1_s75)))-  (let ((l1_s1730 (xor l1_s402 l1_s1729)))-  (let ((l1_s1731 (ite l1_s1573 l1_s1730 l1_s1729)))-  (let ((l1_s1732 (xor l1_s378 l1_s1731)))-  (let ((l1_s1733 (ite l1_s1577 l1_s1732 l1_s1731)))-  (let ((l1_s1734 (xor l1_s356 l1_s1733)))-  (let ((l1_s1735 (ite l1_s1583 l1_s1734 l1_s1733)))-  (let ((l1_s1736 (xor l1_s336 l1_s1735)))-  (let ((l1_s1737 (ite l1_s1591 l1_s1736 l1_s1735)))-  (let ((l1_s1738 (xor l1_s318 l1_s1737)))-  (let ((l1_s1739 (ite l1_s1601 l1_s1738 l1_s1737)))-  (let ((l1_s1740 (xor l1_s302 l1_s1739)))-  (let ((l1_s1741 (ite l1_s1613 l1_s1740 l1_s1739)))-  (let ((l1_s1742 (xor l1_s288 l1_s1741)))-  (let ((l1_s1743 (ite l1_s1627 l1_s1742 l1_s1741)))-  (let ((l1_s1744 (xor l1_s276 l1_s1743)))-  (let ((l1_s1745 (ite l1_s1643 l1_s1744 l1_s1743)))-  (let ((l1_s1746 (xor l1_s266 l1_s1745)))-  (let ((l1_s1747 (ite l1_s1661 l1_s1746 l1_s1745)))-  (let ((l1_s1748 (xor l1_s258 l1_s1747)))-  (let ((l1_s1749 (ite l1_s1681 l1_s1748 l1_s1747)))-  (let ((l1_s1750 (xor l1_s252 l1_s1749)))-  (let ((l1_s1751 (ite l1_s1703 l1_s1750 l1_s1749)))-  (let ((l1_s1752 (xor l1_s248 l1_s1751)))-  (let ((l1_s1753 (ite l1_s1727 l1_s1752 l1_s1751)))-  (let ((l1_s1754 (xor l1_s80 l1_s456)))-  (let ((l1_s1755 (ite l1_s9 l1_s1754 l1_s80)))-  (let ((l1_s1756 (xor l1_s428 l1_s1755)))-  (let ((l1_s1757 (ite l1_s1573 l1_s1756 l1_s1755)))-  (let ((l1_s1758 (xor l1_s402 l1_s1757)))-  (let ((l1_s1759 (ite l1_s1577 l1_s1758 l1_s1757)))-  (let ((l1_s1760 (xor l1_s378 l1_s1759)))-  (let ((l1_s1761 (ite l1_s1583 l1_s1760 l1_s1759)))-  (let ((l1_s1762 (xor l1_s356 l1_s1761)))-  (let ((l1_s1763 (ite l1_s1591 l1_s1762 l1_s1761)))-  (let ((l1_s1764 (xor l1_s336 l1_s1763)))-  (let ((l1_s1765 (ite l1_s1601 l1_s1764 l1_s1763)))-  (let ((l1_s1766 (xor l1_s318 l1_s1765)))-  (let ((l1_s1767 (ite l1_s1613 l1_s1766 l1_s1765)))-  (let ((l1_s1768 (xor l1_s302 l1_s1767)))-  (let ((l1_s1769 (ite l1_s1627 l1_s1768 l1_s1767)))-  (let ((l1_s1770 (xor l1_s288 l1_s1769)))-  (let ((l1_s1771 (ite l1_s1643 l1_s1770 l1_s1769)))-  (let ((l1_s1772 (xor l1_s276 l1_s1771)))-  (let ((l1_s1773 (ite l1_s1661 l1_s1772 l1_s1771)))-  (let ((l1_s1774 (xor l1_s266 l1_s1773)))-  (let ((l1_s1775 (ite l1_s1681 l1_s1774 l1_s1773)))-  (let ((l1_s1776 (xor l1_s258 l1_s1775)))-  (let ((l1_s1777 (ite l1_s1703 l1_s1776 l1_s1775)))-  (let ((l1_s1778 (xor l1_s252 l1_s1777)))-  (let ((l1_s1779 (ite l1_s1727 l1_s1778 l1_s1777)))-  (let ((l1_s1780 (xor l1_s248 l1_s1779)))-  (let ((l1_s1781 (ite l1_s1753 l1_s1780 l1_s1779)))-  (let ((l1_s1782 (xor l1_s85 l1_s486)))-  (let ((l1_s1783 (ite l1_s9 l1_s1782 l1_s85)))-  (let ((l1_s1784 (xor l1_s456 l1_s1783)))-  (let ((l1_s1785 (ite l1_s1573 l1_s1784 l1_s1783)))-  (let ((l1_s1786 (xor l1_s428 l1_s1785)))-  (let ((l1_s1787 (ite l1_s1577 l1_s1786 l1_s1785)))-  (let ((l1_s1788 (xor l1_s402 l1_s1787)))-  (let ((l1_s1789 (ite l1_s1583 l1_s1788 l1_s1787)))-  (let ((l1_s1790 (xor l1_s378 l1_s1789)))-  (let ((l1_s1791 (ite l1_s1591 l1_s1790 l1_s1789)))-  (let ((l1_s1792 (xor l1_s356 l1_s1791)))-  (let ((l1_s1793 (ite l1_s1601 l1_s1792 l1_s1791)))-  (let ((l1_s1794 (xor l1_s336 l1_s1793)))-  (let ((l1_s1795 (ite l1_s1613 l1_s1794 l1_s1793)))-  (let ((l1_s1796 (xor l1_s318 l1_s1795)))-  (let ((l1_s1797 (ite l1_s1627 l1_s1796 l1_s1795)))-  (let ((l1_s1798 (xor l1_s302 l1_s1797)))-  (let ((l1_s1799 (ite l1_s1643 l1_s1798 l1_s1797)))-  (let ((l1_s1800 (xor l1_s288 l1_s1799)))-  (let ((l1_s1801 (ite l1_s1661 l1_s1800 l1_s1799)))-  (let ((l1_s1802 (xor l1_s276 l1_s1801)))-  (let ((l1_s1803 (ite l1_s1681 l1_s1802 l1_s1801)))-  (let ((l1_s1804 (xor l1_s266 l1_s1803)))-  (let ((l1_s1805 (ite l1_s1703 l1_s1804 l1_s1803)))-  (let ((l1_s1806 (xor l1_s258 l1_s1805)))-  (let ((l1_s1807 (ite l1_s1727 l1_s1806 l1_s1805)))-  (let ((l1_s1808 (xor l1_s252 l1_s1807)))-  (let ((l1_s1809 (ite l1_s1753 l1_s1808 l1_s1807)))-  (let ((l1_s1810 (xor l1_s248 l1_s1809)))-  (let ((l1_s1811 (ite l1_s1781 l1_s1810 l1_s1809)))-  (let ((l1_s1812 (xor l1_s4 l1_s90)))-  (let ((l1_s1813 (ite l1_s9 l1_s1812 l1_s90)))-  (let ((l1_s1814 (xor l1_s486 l1_s1813)))-  (let ((l1_s1815 (ite l1_s1573 l1_s1814 l1_s1813)))-  (let ((l1_s1816 (xor l1_s456 l1_s1815)))-  (let ((l1_s1817 (ite l1_s1577 l1_s1816 l1_s1815)))-  (let ((l1_s1818 (xor l1_s428 l1_s1817)))-  (let ((l1_s1819 (ite l1_s1583 l1_s1818 l1_s1817)))-  (let ((l1_s1820 (xor l1_s402 l1_s1819)))-  (let ((l1_s1821 (ite l1_s1591 l1_s1820 l1_s1819)))-  (let ((l1_s1822 (xor l1_s378 l1_s1821)))-  (let ((l1_s1823 (ite l1_s1601 l1_s1822 l1_s1821)))-  (let ((l1_s1824 (xor l1_s356 l1_s1823)))-  (let ((l1_s1825 (ite l1_s1613 l1_s1824 l1_s1823)))-  (let ((l1_s1826 (xor l1_s336 l1_s1825)))-  (let ((l1_s1827 (ite l1_s1627 l1_s1826 l1_s1825)))-  (let ((l1_s1828 (xor l1_s318 l1_s1827)))-  (let ((l1_s1829 (ite l1_s1643 l1_s1828 l1_s1827)))-  (let ((l1_s1830 (xor l1_s302 l1_s1829)))-  (let ((l1_s1831 (ite l1_s1661 l1_s1830 l1_s1829)))-  (let ((l1_s1832 (xor l1_s288 l1_s1831)))-  (let ((l1_s1833 (ite l1_s1681 l1_s1832 l1_s1831)))-  (let ((l1_s1834 (xor l1_s276 l1_s1833)))-  (let ((l1_s1835 (ite l1_s1703 l1_s1834 l1_s1833)))-  (let ((l1_s1836 (xor l1_s266 l1_s1835)))-  (let ((l1_s1837 (ite l1_s1727 l1_s1836 l1_s1835)))-  (let ((l1_s1838 (xor l1_s258 l1_s1837)))-  (let ((l1_s1839 (ite l1_s1753 l1_s1838 l1_s1837)))-  (let ((l1_s1840 (xor l1_s252 l1_s1839)))-  (let ((l1_s1841 (ite l1_s1781 l1_s1840 l1_s1839)))-  (let ((l1_s1842 (xor l1_s248 l1_s1841)))-  (let ((l1_s1843 (ite l1_s1811 l1_s1842 l1_s1841)))-  (let ((l1_s1844 (xor l1_s4 l1_s95)))-  (let ((l1_s1845 (ite l1_s1573 l1_s1844 l1_s95)))-  (let ((l1_s1846 (xor l1_s486 l1_s1845)))-  (let ((l1_s1847 (ite l1_s1577 l1_s1846 l1_s1845)))-  (let ((l1_s1848 (xor l1_s456 l1_s1847)))-  (let ((l1_s1849 (ite l1_s1583 l1_s1848 l1_s1847)))-  (let ((l1_s1850 (xor l1_s428 l1_s1849)))-  (let ((l1_s1851 (ite l1_s1591 l1_s1850 l1_s1849)))-  (let ((l1_s1852 (xor l1_s402 l1_s1851)))-  (let ((l1_s1853 (ite l1_s1601 l1_s1852 l1_s1851)))-  (let ((l1_s1854 (xor l1_s378 l1_s1853)))-  (let ((l1_s1855 (ite l1_s1613 l1_s1854 l1_s1853)))-  (let ((l1_s1856 (xor l1_s356 l1_s1855)))-  (let ((l1_s1857 (ite l1_s1627 l1_s1856 l1_s1855)))-  (let ((l1_s1858 (xor l1_s336 l1_s1857)))-  (let ((l1_s1859 (ite l1_s1643 l1_s1858 l1_s1857)))-  (let ((l1_s1860 (xor l1_s318 l1_s1859)))-  (let ((l1_s1861 (ite l1_s1661 l1_s1860 l1_s1859)))-  (let ((l1_s1862 (xor l1_s302 l1_s1861)))-  (let ((l1_s1863 (ite l1_s1681 l1_s1862 l1_s1861)))-  (let ((l1_s1864 (xor l1_s288 l1_s1863)))-  (let ((l1_s1865 (ite l1_s1703 l1_s1864 l1_s1863)))-  (let ((l1_s1866 (xor l1_s276 l1_s1865)))-  (let ((l1_s1867 (ite l1_s1727 l1_s1866 l1_s1865)))-  (let ((l1_s1868 (xor l1_s266 l1_s1867)))-  (let ((l1_s1869 (ite l1_s1753 l1_s1868 l1_s1867)))-  (let ((l1_s1870 (xor l1_s258 l1_s1869)))-  (let ((l1_s1871 (ite l1_s1781 l1_s1870 l1_s1869)))-  (let ((l1_s1872 (xor l1_s252 l1_s1871)))-  (let ((l1_s1873 (ite l1_s1811 l1_s1872 l1_s1871)))-  (let ((l1_s1874 (xor l1_s248 l1_s1873)))-  (let ((l1_s1875 (ite l1_s1843 l1_s1874 l1_s1873)))-  (let ((l1_s1876 (xor l1_s4 l1_s100)))-  (let ((l1_s1877 (ite l1_s1577 l1_s1876 l1_s100)))-  (let ((l1_s1878 (xor l1_s486 l1_s1877)))-  (let ((l1_s1879 (ite l1_s1583 l1_s1878 l1_s1877)))-  (let ((l1_s1880 (xor l1_s456 l1_s1879)))-  (let ((l1_s1881 (ite l1_s1591 l1_s1880 l1_s1879)))-  (let ((l1_s1882 (xor l1_s428 l1_s1881)))-  (let ((l1_s1883 (ite l1_s1601 l1_s1882 l1_s1881)))-  (let ((l1_s1884 (xor l1_s402 l1_s1883)))-  (let ((l1_s1885 (ite l1_s1613 l1_s1884 l1_s1883)))-  (let ((l1_s1886 (xor l1_s378 l1_s1885)))-  (let ((l1_s1887 (ite l1_s1627 l1_s1886 l1_s1885)))-  (let ((l1_s1888 (xor l1_s356 l1_s1887)))-  (let ((l1_s1889 (ite l1_s1643 l1_s1888 l1_s1887)))-  (let ((l1_s1890 (xor l1_s336 l1_s1889)))-  (let ((l1_s1891 (ite l1_s1661 l1_s1890 l1_s1889)))-  (let ((l1_s1892 (xor l1_s318 l1_s1891)))-  (let ((l1_s1893 (ite l1_s1681 l1_s1892 l1_s1891)))-  (let ((l1_s1894 (xor l1_s302 l1_s1893)))-  (let ((l1_s1895 (ite l1_s1703 l1_s1894 l1_s1893)))-  (let ((l1_s1896 (xor l1_s288 l1_s1895)))-  (let ((l1_s1897 (ite l1_s1727 l1_s1896 l1_s1895)))-  (let ((l1_s1898 (xor l1_s276 l1_s1897)))-  (let ((l1_s1899 (ite l1_s1753 l1_s1898 l1_s1897)))-  (let ((l1_s1900 (xor l1_s266 l1_s1899)))-  (let ((l1_s1901 (ite l1_s1781 l1_s1900 l1_s1899)))-  (let ((l1_s1902 (xor l1_s258 l1_s1901)))-  (let ((l1_s1903 (ite l1_s1811 l1_s1902 l1_s1901)))-  (let ((l1_s1904 (xor l1_s252 l1_s1903)))-  (let ((l1_s1905 (ite l1_s1843 l1_s1904 l1_s1903)))-  (let ((l1_s1906 (xor l1_s248 l1_s1905)))-  (let ((l1_s1907 (ite l1_s1875 l1_s1906 l1_s1905)))-  (let ((l1_s1908 (xor l1_s4 l1_s105)))-  (let ((l1_s1909 (ite l1_s1583 l1_s1908 l1_s105)))-  (let ((l1_s1910 (xor l1_s486 l1_s1909)))-  (let ((l1_s1911 (ite l1_s1591 l1_s1910 l1_s1909)))-  (let ((l1_s1912 (xor l1_s456 l1_s1911)))-  (let ((l1_s1913 (ite l1_s1601 l1_s1912 l1_s1911)))-  (let ((l1_s1914 (xor l1_s428 l1_s1913)))-  (let ((l1_s1915 (ite l1_s1613 l1_s1914 l1_s1913)))-  (let ((l1_s1916 (xor l1_s402 l1_s1915)))-  (let ((l1_s1917 (ite l1_s1627 l1_s1916 l1_s1915)))-  (let ((l1_s1918 (xor l1_s378 l1_s1917)))-  (let ((l1_s1919 (ite l1_s1643 l1_s1918 l1_s1917)))-  (let ((l1_s1920 (xor l1_s356 l1_s1919)))-  (let ((l1_s1921 (ite l1_s1661 l1_s1920 l1_s1919)))-  (let ((l1_s1922 (xor l1_s336 l1_s1921)))-  (let ((l1_s1923 (ite l1_s1681 l1_s1922 l1_s1921)))-  (let ((l1_s1924 (xor l1_s318 l1_s1923)))-  (let ((l1_s1925 (ite l1_s1703 l1_s1924 l1_s1923)))-  (let ((l1_s1926 (xor l1_s302 l1_s1925)))-  (let ((l1_s1927 (ite l1_s1727 l1_s1926 l1_s1925)))-  (let ((l1_s1928 (xor l1_s288 l1_s1927)))-  (let ((l1_s1929 (ite l1_s1753 l1_s1928 l1_s1927)))-  (let ((l1_s1930 (xor l1_s276 l1_s1929)))-  (let ((l1_s1931 (ite l1_s1781 l1_s1930 l1_s1929)))-  (let ((l1_s1932 (xor l1_s266 l1_s1931)))-  (let ((l1_s1933 (ite l1_s1811 l1_s1932 l1_s1931)))-  (let ((l1_s1934 (xor l1_s258 l1_s1933)))-  (let ((l1_s1935 (ite l1_s1843 l1_s1934 l1_s1933)))-  (let ((l1_s1936 (xor l1_s252 l1_s1935)))-  (let ((l1_s1937 (ite l1_s1875 l1_s1936 l1_s1935)))-  (let ((l1_s1938 (xor l1_s248 l1_s1937)))-  (let ((l1_s1939 (ite l1_s1907 l1_s1938 l1_s1937)))-  (let ((l1_s1940 (xor l1_s4 l1_s110)))-  (let ((l1_s1941 (ite l1_s1591 l1_s1940 l1_s110)))-  (let ((l1_s1942 (xor l1_s486 l1_s1941)))-  (let ((l1_s1943 (ite l1_s1601 l1_s1942 l1_s1941)))-  (let ((l1_s1944 (xor l1_s456 l1_s1943)))-  (let ((l1_s1945 (ite l1_s1613 l1_s1944 l1_s1943)))-  (let ((l1_s1946 (xor l1_s428 l1_s1945)))-  (let ((l1_s1947 (ite l1_s1627 l1_s1946 l1_s1945)))-  (let ((l1_s1948 (xor l1_s402 l1_s1947)))-  (let ((l1_s1949 (ite l1_s1643 l1_s1948 l1_s1947)))-  (let ((l1_s1950 (xor l1_s378 l1_s1949)))-  (let ((l1_s1951 (ite l1_s1661 l1_s1950 l1_s1949)))-  (let ((l1_s1952 (xor l1_s356 l1_s1951)))-  (let ((l1_s1953 (ite l1_s1681 l1_s1952 l1_s1951)))-  (let ((l1_s1954 (xor l1_s336 l1_s1953)))-  (let ((l1_s1955 (ite l1_s1703 l1_s1954 l1_s1953)))-  (let ((l1_s1956 (xor l1_s318 l1_s1955)))-  (let ((l1_s1957 (ite l1_s1727 l1_s1956 l1_s1955)))-  (let ((l1_s1958 (xor l1_s302 l1_s1957)))-  (let ((l1_s1959 (ite l1_s1753 l1_s1958 l1_s1957)))-  (let ((l1_s1960 (xor l1_s288 l1_s1959)))-  (let ((l1_s1961 (ite l1_s1781 l1_s1960 l1_s1959)))-  (let ((l1_s1962 (xor l1_s276 l1_s1961)))-  (let ((l1_s1963 (ite l1_s1811 l1_s1962 l1_s1961)))-  (let ((l1_s1964 (xor l1_s266 l1_s1963)))-  (let ((l1_s1965 (ite l1_s1843 l1_s1964 l1_s1963)))-  (let ((l1_s1966 (xor l1_s258 l1_s1965)))-  (let ((l1_s1967 (ite l1_s1875 l1_s1966 l1_s1965)))-  (let ((l1_s1968 (xor l1_s252 l1_s1967)))-  (let ((l1_s1969 (ite l1_s1907 l1_s1968 l1_s1967)))-  (let ((l1_s1970 (xor l1_s248 l1_s1969)))-  (let ((l1_s1971 (ite l1_s1939 l1_s1970 l1_s1969)))-  (let ((l1_s1972 (xor l1_s4 l1_s115)))-  (let ((l1_s1973 (ite l1_s1601 l1_s1972 l1_s115)))-  (let ((l1_s1974 (xor l1_s486 l1_s1973)))-  (let ((l1_s1975 (ite l1_s1613 l1_s1974 l1_s1973)))-  (let ((l1_s1976 (xor l1_s456 l1_s1975)))-  (let ((l1_s1977 (ite l1_s1627 l1_s1976 l1_s1975)))-  (let ((l1_s1978 (xor l1_s428 l1_s1977)))-  (let ((l1_s1979 (ite l1_s1643 l1_s1978 l1_s1977)))-  (let ((l1_s1980 (xor l1_s402 l1_s1979)))-  (let ((l1_s1981 (ite l1_s1661 l1_s1980 l1_s1979)))-  (let ((l1_s1982 (xor l1_s378 l1_s1981)))-  (let ((l1_s1983 (ite l1_s1681 l1_s1982 l1_s1981)))-  (let ((l1_s1984 (xor l1_s356 l1_s1983)))-  (let ((l1_s1985 (ite l1_s1703 l1_s1984 l1_s1983)))-  (let ((l1_s1986 (xor l1_s336 l1_s1985)))-  (let ((l1_s1987 (ite l1_s1727 l1_s1986 l1_s1985)))-  (let ((l1_s1988 (xor l1_s318 l1_s1987)))-  (let ((l1_s1989 (ite l1_s1753 l1_s1988 l1_s1987)))-  (let ((l1_s1990 (xor l1_s302 l1_s1989)))-  (let ((l1_s1991 (ite l1_s1781 l1_s1990 l1_s1989)))-  (let ((l1_s1992 (xor l1_s288 l1_s1991)))-  (let ((l1_s1993 (ite l1_s1811 l1_s1992 l1_s1991)))-  (let ((l1_s1994 (xor l1_s276 l1_s1993)))-  (let ((l1_s1995 (ite l1_s1843 l1_s1994 l1_s1993)))-  (let ((l1_s1996 (xor l1_s266 l1_s1995)))-  (let ((l1_s1997 (ite l1_s1875 l1_s1996 l1_s1995)))-  (let ((l1_s1998 (xor l1_s258 l1_s1997)))-  (let ((l1_s1999 (ite l1_s1907 l1_s1998 l1_s1997)))-  (let ((l1_s2000 (xor l1_s252 l1_s1999)))-  (let ((l1_s2001 (ite l1_s1939 l1_s2000 l1_s1999)))-  (let ((l1_s2002 (xor l1_s248 l1_s2001)))-  (let ((l1_s2003 (ite l1_s1971 l1_s2002 l1_s2001)))-  (let ((l1_s2004 (xor l1_s4 l1_s120)))-  (let ((l1_s2005 (ite l1_s1613 l1_s2004 l1_s120)))-  (let ((l1_s2006 (xor l1_s486 l1_s2005)))-  (let ((l1_s2007 (ite l1_s1627 l1_s2006 l1_s2005)))-  (let ((l1_s2008 (xor l1_s456 l1_s2007)))-  (let ((l1_s2009 (ite l1_s1643 l1_s2008 l1_s2007)))-  (let ((l1_s2010 (xor l1_s428 l1_s2009)))-  (let ((l1_s2011 (ite l1_s1661 l1_s2010 l1_s2009)))-  (let ((l1_s2012 (xor l1_s402 l1_s2011)))-  (let ((l1_s2013 (ite l1_s1681 l1_s2012 l1_s2011)))-  (let ((l1_s2014 (xor l1_s378 l1_s2013)))-  (let ((l1_s2015 (ite l1_s1703 l1_s2014 l1_s2013)))-  (let ((l1_s2016 (xor l1_s356 l1_s2015)))-  (let ((l1_s2017 (ite l1_s1727 l1_s2016 l1_s2015)))-  (let ((l1_s2018 (xor l1_s336 l1_s2017)))-  (let ((l1_s2019 (ite l1_s1753 l1_s2018 l1_s2017)))-  (let ((l1_s2020 (xor l1_s318 l1_s2019)))-  (let ((l1_s2021 (ite l1_s1781 l1_s2020 l1_s2019)))-  (let ((l1_s2022 (xor l1_s302 l1_s2021)))-  (let ((l1_s2023 (ite l1_s1811 l1_s2022 l1_s2021)))-  (let ((l1_s2024 (xor l1_s288 l1_s2023)))-  (let ((l1_s2025 (ite l1_s1843 l1_s2024 l1_s2023)))-  (let ((l1_s2026 (xor l1_s276 l1_s2025)))-  (let ((l1_s2027 (ite l1_s1875 l1_s2026 l1_s2025)))-  (let ((l1_s2028 (xor l1_s266 l1_s2027)))-  (let ((l1_s2029 (ite l1_s1907 l1_s2028 l1_s2027)))-  (let ((l1_s2030 (xor l1_s258 l1_s2029)))-  (let ((l1_s2031 (ite l1_s1939 l1_s2030 l1_s2029)))-  (let ((l1_s2032 (xor l1_s252 l1_s2031)))-  (let ((l1_s2033 (ite l1_s1971 l1_s2032 l1_s2031)))-  (let ((l1_s2034 (xor l1_s248 l1_s2033)))-  (let ((l1_s2035 (ite l1_s2003 l1_s2034 l1_s2033)))-  (let ((l1_s2036 (xor l1_s4 l1_s125)))-  (let ((l1_s2037 (ite l1_s1627 l1_s2036 l1_s125)))-  (let ((l1_s2038 (xor l1_s486 l1_s2037)))-  (let ((l1_s2039 (ite l1_s1643 l1_s2038 l1_s2037)))-  (let ((l1_s2040 (xor l1_s456 l1_s2039)))-  (let ((l1_s2041 (ite l1_s1661 l1_s2040 l1_s2039)))-  (let ((l1_s2042 (xor l1_s428 l1_s2041)))-  (let ((l1_s2043 (ite l1_s1681 l1_s2042 l1_s2041)))-  (let ((l1_s2044 (xor l1_s402 l1_s2043)))-  (let ((l1_s2045 (ite l1_s1703 l1_s2044 l1_s2043)))-  (let ((l1_s2046 (xor l1_s378 l1_s2045)))-  (let ((l1_s2047 (ite l1_s1727 l1_s2046 l1_s2045)))-  (let ((l1_s2048 (xor l1_s356 l1_s2047)))-  (let ((l1_s2049 (ite l1_s1753 l1_s2048 l1_s2047)))-  (let ((l1_s2050 (xor l1_s336 l1_s2049)))-  (let ((l1_s2051 (ite l1_s1781 l1_s2050 l1_s2049)))-  (let ((l1_s2052 (xor l1_s318 l1_s2051)))-  (let ((l1_s2053 (ite l1_s1811 l1_s2052 l1_s2051)))-  (let ((l1_s2054 (xor l1_s302 l1_s2053)))-  (let ((l1_s2055 (ite l1_s1843 l1_s2054 l1_s2053)))-  (let ((l1_s2056 (xor l1_s288 l1_s2055)))-  (let ((l1_s2057 (ite l1_s1875 l1_s2056 l1_s2055)))-  (let ((l1_s2058 (xor l1_s276 l1_s2057)))-  (let ((l1_s2059 (ite l1_s1907 l1_s2058 l1_s2057)))-  (let ((l1_s2060 (xor l1_s266 l1_s2059)))-  (let ((l1_s2061 (ite l1_s1939 l1_s2060 l1_s2059)))-  (let ((l1_s2062 (xor l1_s258 l1_s2061)))-  (let ((l1_s2063 (ite l1_s1971 l1_s2062 l1_s2061)))-  (let ((l1_s2064 (xor l1_s252 l1_s2063)))-  (let ((l1_s2065 (ite l1_s2003 l1_s2064 l1_s2063)))-  (let ((l1_s2066 (xor l1_s248 l1_s2065)))-  (let ((l1_s2067 (ite l1_s2035 l1_s2066 l1_s2065)))-  (let ((l1_s2068 (xor l1_s4 l1_s130)))-  (let ((l1_s2069 (ite l1_s1643 l1_s2068 l1_s130)))-  (let ((l1_s2070 (xor l1_s486 l1_s2069)))-  (let ((l1_s2071 (ite l1_s1661 l1_s2070 l1_s2069)))-  (let ((l1_s2072 (xor l1_s456 l1_s2071)))-  (let ((l1_s2073 (ite l1_s1681 l1_s2072 l1_s2071)))-  (let ((l1_s2074 (xor l1_s428 l1_s2073)))-  (let ((l1_s2075 (ite l1_s1703 l1_s2074 l1_s2073)))-  (let ((l1_s2076 (xor l1_s402 l1_s2075)))-  (let ((l1_s2077 (ite l1_s1727 l1_s2076 l1_s2075)))-  (let ((l1_s2078 (xor l1_s378 l1_s2077)))-  (let ((l1_s2079 (ite l1_s1753 l1_s2078 l1_s2077)))-  (let ((l1_s2080 (xor l1_s356 l1_s2079)))-  (let ((l1_s2081 (ite l1_s1781 l1_s2080 l1_s2079)))-  (let ((l1_s2082 (xor l1_s336 l1_s2081)))-  (let ((l1_s2083 (ite l1_s1811 l1_s2082 l1_s2081)))-  (let ((l1_s2084 (xor l1_s318 l1_s2083)))-  (let ((l1_s2085 (ite l1_s1843 l1_s2084 l1_s2083)))-  (let ((l1_s2086 (xor l1_s302 l1_s2085)))-  (let ((l1_s2087 (ite l1_s1875 l1_s2086 l1_s2085)))-  (let ((l1_s2088 (xor l1_s288 l1_s2087)))-  (let ((l1_s2089 (ite l1_s1907 l1_s2088 l1_s2087)))-  (let ((l1_s2090 (xor l1_s276 l1_s2089)))-  (let ((l1_s2091 (ite l1_s1939 l1_s2090 l1_s2089)))-  (let ((l1_s2092 (xor l1_s266 l1_s2091)))-  (let ((l1_s2093 (ite l1_s1971 l1_s2092 l1_s2091)))-  (let ((l1_s2094 (xor l1_s258 l1_s2093)))-  (let ((l1_s2095 (ite l1_s2003 l1_s2094 l1_s2093)))-  (let ((l1_s2096 (xor l1_s252 l1_s2095)))-  (let ((l1_s2097 (ite l1_s2035 l1_s2096 l1_s2095)))-  (let ((l1_s2098 (xor l1_s248 l1_s2097)))-  (let ((l1_s2099 (ite l1_s2067 l1_s2098 l1_s2097)))-  (let ((l1_s2100 (xor l1_s4 l1_s135)))-  (let ((l1_s2101 (ite l1_s1661 l1_s2100 l1_s135)))-  (let ((l1_s2102 (xor l1_s486 l1_s2101)))-  (let ((l1_s2103 (ite l1_s1681 l1_s2102 l1_s2101)))-  (let ((l1_s2104 (xor l1_s456 l1_s2103)))-  (let ((l1_s2105 (ite l1_s1703 l1_s2104 l1_s2103)))-  (let ((l1_s2106 (xor l1_s428 l1_s2105)))-  (let ((l1_s2107 (ite l1_s1727 l1_s2106 l1_s2105)))-  (let ((l1_s2108 (xor l1_s402 l1_s2107)))-  (let ((l1_s2109 (ite l1_s1753 l1_s2108 l1_s2107)))-  (let ((l1_s2110 (xor l1_s378 l1_s2109)))-  (let ((l1_s2111 (ite l1_s1781 l1_s2110 l1_s2109)))-  (let ((l1_s2112 (xor l1_s356 l1_s2111)))-  (let ((l1_s2113 (ite l1_s1811 l1_s2112 l1_s2111)))-  (let ((l1_s2114 (xor l1_s336 l1_s2113)))-  (let ((l1_s2115 (ite l1_s1843 l1_s2114 l1_s2113)))-  (let ((l1_s2116 (xor l1_s318 l1_s2115)))-  (let ((l1_s2117 (ite l1_s1875 l1_s2116 l1_s2115)))-  (let ((l1_s2118 (xor l1_s302 l1_s2117)))-  (let ((l1_s2119 (ite l1_s1907 l1_s2118 l1_s2117)))-  (let ((l1_s2120 (xor l1_s288 l1_s2119)))-  (let ((l1_s2121 (ite l1_s1939 l1_s2120 l1_s2119)))-  (let ((l1_s2122 (xor l1_s276 l1_s2121)))-  (let ((l1_s2123 (ite l1_s1971 l1_s2122 l1_s2121)))-  (let ((l1_s2124 (xor l1_s266 l1_s2123)))-  (let ((l1_s2125 (ite l1_s2003 l1_s2124 l1_s2123)))-  (let ((l1_s2126 (xor l1_s258 l1_s2125)))-  (let ((l1_s2127 (ite l1_s2035 l1_s2126 l1_s2125)))-  (let ((l1_s2128 (xor l1_s252 l1_s2127)))-  (let ((l1_s2129 (ite l1_s2067 l1_s2128 l1_s2127)))-  (let ((l1_s2130 (xor l1_s248 l1_s2129)))-  (let ((l1_s2131 (ite l1_s2099 l1_s2130 l1_s2129)))-  (let ((l1_s2132 (xor l1_s4 l1_s140)))-  (let ((l1_s2133 (ite l1_s1681 l1_s2132 l1_s140)))-  (let ((l1_s2134 (xor l1_s486 l1_s2133)))-  (let ((l1_s2135 (ite l1_s1703 l1_s2134 l1_s2133)))-  (let ((l1_s2136 (xor l1_s456 l1_s2135)))-  (let ((l1_s2137 (ite l1_s1727 l1_s2136 l1_s2135)))-  (let ((l1_s2138 (xor l1_s428 l1_s2137)))-  (let ((l1_s2139 (ite l1_s1753 l1_s2138 l1_s2137)))-  (let ((l1_s2140 (xor l1_s402 l1_s2139)))-  (let ((l1_s2141 (ite l1_s1781 l1_s2140 l1_s2139)))-  (let ((l1_s2142 (xor l1_s378 l1_s2141)))-  (let ((l1_s2143 (ite l1_s1811 l1_s2142 l1_s2141)))-  (let ((l1_s2144 (xor l1_s356 l1_s2143)))-  (let ((l1_s2145 (ite l1_s1843 l1_s2144 l1_s2143)))-  (let ((l1_s2146 (xor l1_s336 l1_s2145)))-  (let ((l1_s2147 (ite l1_s1875 l1_s2146 l1_s2145)))-  (let ((l1_s2148 (xor l1_s318 l1_s2147)))-  (let ((l1_s2149 (ite l1_s1907 l1_s2148 l1_s2147)))-  (let ((l1_s2150 (xor l1_s302 l1_s2149)))-  (let ((l1_s2151 (ite l1_s1939 l1_s2150 l1_s2149)))-  (let ((l1_s2152 (xor l1_s288 l1_s2151)))-  (let ((l1_s2153 (ite l1_s1971 l1_s2152 l1_s2151)))-  (let ((l1_s2154 (xor l1_s276 l1_s2153)))-  (let ((l1_s2155 (ite l1_s2003 l1_s2154 l1_s2153)))-  (let ((l1_s2156 (xor l1_s266 l1_s2155)))-  (let ((l1_s2157 (ite l1_s2035 l1_s2156 l1_s2155)))-  (let ((l1_s2158 (xor l1_s258 l1_s2157)))-  (let ((l1_s2159 (ite l1_s2067 l1_s2158 l1_s2157)))-  (let ((l1_s2160 (xor l1_s252 l1_s2159)))-  (let ((l1_s2161 (ite l1_s2099 l1_s2160 l1_s2159)))-  (let ((l1_s2162 (xor l1_s248 l1_s2161)))-  (let ((l1_s2163 (ite l1_s2131 l1_s2162 l1_s2161)))-  (let ((l1_s2164 (xor l1_s4 l1_s145)))-  (let ((l1_s2165 (ite l1_s1703 l1_s2164 l1_s145)))-  (let ((l1_s2166 (xor l1_s486 l1_s2165)))-  (let ((l1_s2167 (ite l1_s1727 l1_s2166 l1_s2165)))-  (let ((l1_s2168 (xor l1_s456 l1_s2167)))-  (let ((l1_s2169 (ite l1_s1753 l1_s2168 l1_s2167)))-  (let ((l1_s2170 (xor l1_s428 l1_s2169)))-  (let ((l1_s2171 (ite l1_s1781 l1_s2170 l1_s2169)))-  (let ((l1_s2172 (xor l1_s402 l1_s2171)))-  (let ((l1_s2173 (ite l1_s1811 l1_s2172 l1_s2171)))-  (let ((l1_s2174 (xor l1_s378 l1_s2173)))-  (let ((l1_s2175 (ite l1_s1843 l1_s2174 l1_s2173)))-  (let ((l1_s2176 (xor l1_s356 l1_s2175)))-  (let ((l1_s2177 (ite l1_s1875 l1_s2176 l1_s2175)))-  (let ((l1_s2178 (xor l1_s336 l1_s2177)))-  (let ((l1_s2179 (ite l1_s1907 l1_s2178 l1_s2177)))-  (let ((l1_s2180 (xor l1_s318 l1_s2179)))-  (let ((l1_s2181 (ite l1_s1939 l1_s2180 l1_s2179)))-  (let ((l1_s2182 (xor l1_s302 l1_s2181)))-  (let ((l1_s2183 (ite l1_s1971 l1_s2182 l1_s2181)))-  (let ((l1_s2184 (xor l1_s288 l1_s2183)))-  (let ((l1_s2185 (ite l1_s2003 l1_s2184 l1_s2183)))-  (let ((l1_s2186 (xor l1_s276 l1_s2185)))-  (let ((l1_s2187 (ite l1_s2035 l1_s2186 l1_s2185)))-  (let ((l1_s2188 (xor l1_s266 l1_s2187)))-  (let ((l1_s2189 (ite l1_s2067 l1_s2188 l1_s2187)))-  (let ((l1_s2190 (xor l1_s258 l1_s2189)))-  (let ((l1_s2191 (ite l1_s2099 l1_s2190 l1_s2189)))-  (let ((l1_s2192 (xor l1_s252 l1_s2191)))-  (let ((l1_s2193 (ite l1_s2131 l1_s2192 l1_s2191)))-  (let ((l1_s2194 (xor l1_s248 l1_s2193)))-  (let ((l1_s2195 (ite l1_s2163 l1_s2194 l1_s2193)))-  (let ((l1_s2196 (xor l1_s4 l1_s150)))-  (let ((l1_s2197 (ite l1_s1727 l1_s2196 l1_s150)))-  (let ((l1_s2198 (xor l1_s486 l1_s2197)))-  (let ((l1_s2199 (ite l1_s1753 l1_s2198 l1_s2197)))-  (let ((l1_s2200 (xor l1_s456 l1_s2199)))-  (let ((l1_s2201 (ite l1_s1781 l1_s2200 l1_s2199)))-  (let ((l1_s2202 (xor l1_s428 l1_s2201)))-  (let ((l1_s2203 (ite l1_s1811 l1_s2202 l1_s2201)))-  (let ((l1_s2204 (xor l1_s402 l1_s2203)))-  (let ((l1_s2205 (ite l1_s1843 l1_s2204 l1_s2203)))-  (let ((l1_s2206 (xor l1_s378 l1_s2205)))-  (let ((l1_s2207 (ite l1_s1875 l1_s2206 l1_s2205)))-  (let ((l1_s2208 (xor l1_s356 l1_s2207)))-  (let ((l1_s2209 (ite l1_s1907 l1_s2208 l1_s2207)))-  (let ((l1_s2210 (xor l1_s336 l1_s2209)))-  (let ((l1_s2211 (ite l1_s1939 l1_s2210 l1_s2209)))-  (let ((l1_s2212 (xor l1_s318 l1_s2211)))-  (let ((l1_s2213 (ite l1_s1971 l1_s2212 l1_s2211)))-  (let ((l1_s2214 (xor l1_s302 l1_s2213)))-  (let ((l1_s2215 (ite l1_s2003 l1_s2214 l1_s2213)))-  (let ((l1_s2216 (xor l1_s288 l1_s2215)))-  (let ((l1_s2217 (ite l1_s2035 l1_s2216 l1_s2215)))-  (let ((l1_s2218 (xor l1_s276 l1_s2217)))-  (let ((l1_s2219 (ite l1_s2067 l1_s2218 l1_s2217)))-  (let ((l1_s2220 (xor l1_s266 l1_s2219)))-  (let ((l1_s2221 (ite l1_s2099 l1_s2220 l1_s2219)))-  (let ((l1_s2222 (xor l1_s258 l1_s2221)))-  (let ((l1_s2223 (ite l1_s2131 l1_s2222 l1_s2221)))-  (let ((l1_s2224 (xor l1_s252 l1_s2223)))-  (let ((l1_s2225 (ite l1_s2163 l1_s2224 l1_s2223)))-  (let ((l1_s2226 (xor l1_s248 l1_s2225)))-  (let ((l1_s2227 (ite l1_s2195 l1_s2226 l1_s2225)))-  (let ((l1_s2228 (xor l1_s4 l1_s155)))-  (let ((l1_s2229 (ite l1_s1753 l1_s2228 l1_s155)))-  (let ((l1_s2230 (xor l1_s486 l1_s2229)))-  (let ((l1_s2231 (ite l1_s1781 l1_s2230 l1_s2229)))-  (let ((l1_s2232 (xor l1_s456 l1_s2231)))-  (let ((l1_s2233 (ite l1_s1811 l1_s2232 l1_s2231)))-  (let ((l1_s2234 (xor l1_s428 l1_s2233)))-  (let ((l1_s2235 (ite l1_s1843 l1_s2234 l1_s2233)))-  (let ((l1_s2236 (xor l1_s402 l1_s2235)))-  (let ((l1_s2237 (ite l1_s1875 l1_s2236 l1_s2235)))-  (let ((l1_s2238 (xor l1_s378 l1_s2237)))-  (let ((l1_s2239 (ite l1_s1907 l1_s2238 l1_s2237)))-  (let ((l1_s2240 (xor l1_s356 l1_s2239)))-  (let ((l1_s2241 (ite l1_s1939 l1_s2240 l1_s2239)))-  (let ((l1_s2242 (xor l1_s336 l1_s2241)))-  (let ((l1_s2243 (ite l1_s1971 l1_s2242 l1_s2241)))-  (let ((l1_s2244 (xor l1_s318 l1_s2243)))-  (let ((l1_s2245 (ite l1_s2003 l1_s2244 l1_s2243)))-  (let ((l1_s2246 (xor l1_s302 l1_s2245)))-  (let ((l1_s2247 (ite l1_s2035 l1_s2246 l1_s2245)))-  (let ((l1_s2248 (xor l1_s288 l1_s2247)))-  (let ((l1_s2249 (ite l1_s2067 l1_s2248 l1_s2247)))-  (let ((l1_s2250 (xor l1_s276 l1_s2249)))-  (let ((l1_s2251 (ite l1_s2099 l1_s2250 l1_s2249)))-  (let ((l1_s2252 (xor l1_s266 l1_s2251)))-  (let ((l1_s2253 (ite l1_s2131 l1_s2252 l1_s2251)))-  (let ((l1_s2254 (xor l1_s258 l1_s2253)))-  (let ((l1_s2255 (ite l1_s2163 l1_s2254 l1_s2253)))-  (let ((l1_s2256 (xor l1_s252 l1_s2255)))-  (let ((l1_s2257 (ite l1_s2195 l1_s2256 l1_s2255)))-  (let ((l1_s2258 (xor l1_s248 l1_s2257)))-  (let ((l1_s2259 (ite l1_s2227 l1_s2258 l1_s2257)))-  (let ((l1_s2260 (xor l1_s4 l1_s160)))-  (let ((l1_s2261 (ite l1_s1781 l1_s2260 l1_s160)))-  (let ((l1_s2262 (xor l1_s486 l1_s2261)))-  (let ((l1_s2263 (ite l1_s1811 l1_s2262 l1_s2261)))-  (let ((l1_s2264 (xor l1_s456 l1_s2263)))-  (let ((l1_s2265 (ite l1_s1843 l1_s2264 l1_s2263)))-  (let ((l1_s2266 (xor l1_s428 l1_s2265)))-  (let ((l1_s2267 (ite l1_s1875 l1_s2266 l1_s2265)))-  (let ((l1_s2268 (xor l1_s402 l1_s2267)))-  (let ((l1_s2269 (ite l1_s1907 l1_s2268 l1_s2267)))-  (let ((l1_s2270 (xor l1_s378 l1_s2269)))-  (let ((l1_s2271 (ite l1_s1939 l1_s2270 l1_s2269)))-  (let ((l1_s2272 (xor l1_s356 l1_s2271)))-  (let ((l1_s2273 (ite l1_s1971 l1_s2272 l1_s2271)))-  (let ((l1_s2274 (xor l1_s336 l1_s2273)))-  (let ((l1_s2275 (ite l1_s2003 l1_s2274 l1_s2273)))-  (let ((l1_s2276 (xor l1_s318 l1_s2275)))-  (let ((l1_s2277 (ite l1_s2035 l1_s2276 l1_s2275)))-  (let ((l1_s2278 (xor l1_s302 l1_s2277)))-  (let ((l1_s2279 (ite l1_s2067 l1_s2278 l1_s2277)))-  (let ((l1_s2280 (xor l1_s288 l1_s2279)))-  (let ((l1_s2281 (ite l1_s2099 l1_s2280 l1_s2279)))-  (let ((l1_s2282 (xor l1_s276 l1_s2281)))-  (let ((l1_s2283 (ite l1_s2131 l1_s2282 l1_s2281)))-  (let ((l1_s2284 (xor l1_s266 l1_s2283)))-  (let ((l1_s2285 (ite l1_s2163 l1_s2284 l1_s2283)))-  (let ((l1_s2286 (xor l1_s258 l1_s2285)))-  (let ((l1_s2287 (ite l1_s2195 l1_s2286 l1_s2285)))-  (let ((l1_s2288 (xor l1_s252 l1_s2287)))-  (let ((l1_s2289 (ite l1_s2227 l1_s2288 l1_s2287)))-  (let ((l1_s2290 (xor l1_s248 l1_s2289)))-  (let ((l1_s2291 (ite l1_s2259 l1_s2290 l1_s2289)))-  (let ((l1_s2292 (xor l1_s4 l1_s165)))-  (let ((l1_s2293 (ite l1_s1811 l1_s2292 l1_s165)))-  (let ((l1_s2294 (xor l1_s486 l1_s2293)))-  (let ((l1_s2295 (ite l1_s1843 l1_s2294 l1_s2293)))-  (let ((l1_s2296 (xor l1_s456 l1_s2295)))-  (let ((l1_s2297 (ite l1_s1875 l1_s2296 l1_s2295)))-  (let ((l1_s2298 (xor l1_s428 l1_s2297)))-  (let ((l1_s2299 (ite l1_s1907 l1_s2298 l1_s2297)))-  (let ((l1_s2300 (xor l1_s402 l1_s2299)))-  (let ((l1_s2301 (ite l1_s1939 l1_s2300 l1_s2299)))-  (let ((l1_s2302 (xor l1_s378 l1_s2301)))-  (let ((l1_s2303 (ite l1_s1971 l1_s2302 l1_s2301)))-  (let ((l1_s2304 (xor l1_s356 l1_s2303)))-  (let ((l1_s2305 (ite l1_s2003 l1_s2304 l1_s2303)))-  (let ((l1_s2306 (xor l1_s336 l1_s2305)))-  (let ((l1_s2307 (ite l1_s2035 l1_s2306 l1_s2305)))-  (let ((l1_s2308 (xor l1_s318 l1_s2307)))-  (let ((l1_s2309 (ite l1_s2067 l1_s2308 l1_s2307)))-  (let ((l1_s2310 (xor l1_s302 l1_s2309)))-  (let ((l1_s2311 (ite l1_s2099 l1_s2310 l1_s2309)))-  (let ((l1_s2312 (xor l1_s288 l1_s2311)))-  (let ((l1_s2313 (ite l1_s2131 l1_s2312 l1_s2311)))-  (let ((l1_s2314 (xor l1_s276 l1_s2313)))-  (let ((l1_s2315 (ite l1_s2163 l1_s2314 l1_s2313)))-  (let ((l1_s2316 (xor l1_s266 l1_s2315)))-  (let ((l1_s2317 (ite l1_s2195 l1_s2316 l1_s2315)))-  (let ((l1_s2318 (xor l1_s258 l1_s2317)))-  (let ((l1_s2319 (ite l1_s2227 l1_s2318 l1_s2317)))-  (let ((l1_s2320 (xor l1_s252 l1_s2319)))-  (let ((l1_s2321 (ite l1_s2259 l1_s2320 l1_s2319)))-  (let ((l1_s2322 (xor l1_s248 l1_s2321)))-  (let ((l1_s2323 (ite l1_s2291 l1_s2322 l1_s2321)))-  (let ((l1_s2324 (xor l1_s4 l1_s170)))-  (let ((l1_s2325 (ite l1_s1843 l1_s2324 l1_s170)))-  (let ((l1_s2326 (xor l1_s486 l1_s2325)))-  (let ((l1_s2327 (ite l1_s1875 l1_s2326 l1_s2325)))-  (let ((l1_s2328 (xor l1_s456 l1_s2327)))-  (let ((l1_s2329 (ite l1_s1907 l1_s2328 l1_s2327)))-  (let ((l1_s2330 (xor l1_s428 l1_s2329)))-  (let ((l1_s2331 (ite l1_s1939 l1_s2330 l1_s2329)))-  (let ((l1_s2332 (xor l1_s402 l1_s2331)))-  (let ((l1_s2333 (ite l1_s1971 l1_s2332 l1_s2331)))-  (let ((l1_s2334 (xor l1_s378 l1_s2333)))-  (let ((l1_s2335 (ite l1_s2003 l1_s2334 l1_s2333)))-  (let ((l1_s2336 (xor l1_s356 l1_s2335)))-  (let ((l1_s2337 (ite l1_s2035 l1_s2336 l1_s2335)))-  (let ((l1_s2338 (xor l1_s336 l1_s2337)))-  (let ((l1_s2339 (ite l1_s2067 l1_s2338 l1_s2337)))-  (let ((l1_s2340 (xor l1_s318 l1_s2339)))-  (let ((l1_s2341 (ite l1_s2099 l1_s2340 l1_s2339)))-  (let ((l1_s2342 (xor l1_s302 l1_s2341)))-  (let ((l1_s2343 (ite l1_s2131 l1_s2342 l1_s2341)))-  (let ((l1_s2344 (xor l1_s288 l1_s2343)))-  (let ((l1_s2345 (ite l1_s2163 l1_s2344 l1_s2343)))-  (let ((l1_s2346 (xor l1_s276 l1_s2345)))-  (let ((l1_s2347 (ite l1_s2195 l1_s2346 l1_s2345)))-  (let ((l1_s2348 (xor l1_s266 l1_s2347)))-  (let ((l1_s2349 (ite l1_s2227 l1_s2348 l1_s2347)))-  (let ((l1_s2350 (xor l1_s258 l1_s2349)))-  (let ((l1_s2351 (ite l1_s2259 l1_s2350 l1_s2349)))-  (let ((l1_s2352 (xor l1_s252 l1_s2351)))-  (let ((l1_s2353 (ite l1_s2291 l1_s2352 l1_s2351)))-  (let ((l1_s2354 (xor l1_s248 l1_s2353)))-  (let ((l1_s2355 (ite l1_s2323 l1_s2354 l1_s2353)))-  (let ((l1_s2356 (xor l1_s4 l1_s175)))-  (let ((l1_s2357 (ite l1_s1875 l1_s2356 l1_s175)))-  (let ((l1_s2358 (xor l1_s486 l1_s2357)))-  (let ((l1_s2359 (ite l1_s1907 l1_s2358 l1_s2357)))-  (let ((l1_s2360 (xor l1_s456 l1_s2359)))-  (let ((l1_s2361 (ite l1_s1939 l1_s2360 l1_s2359)))-  (let ((l1_s2362 (xor l1_s428 l1_s2361)))-  (let ((l1_s2363 (ite l1_s1971 l1_s2362 l1_s2361)))-  (let ((l1_s2364 (xor l1_s402 l1_s2363)))-  (let ((l1_s2365 (ite l1_s2003 l1_s2364 l1_s2363)))-  (let ((l1_s2366 (xor l1_s378 l1_s2365)))-  (let ((l1_s2367 (ite l1_s2035 l1_s2366 l1_s2365)))-  (let ((l1_s2368 (xor l1_s356 l1_s2367)))-  (let ((l1_s2369 (ite l1_s2067 l1_s2368 l1_s2367)))-  (let ((l1_s2370 (xor l1_s336 l1_s2369)))-  (let ((l1_s2371 (ite l1_s2099 l1_s2370 l1_s2369)))-  (let ((l1_s2372 (xor l1_s318 l1_s2371)))-  (let ((l1_s2373 (ite l1_s2131 l1_s2372 l1_s2371)))-  (let ((l1_s2374 (xor l1_s302 l1_s2373)))-  (let ((l1_s2375 (ite l1_s2163 l1_s2374 l1_s2373)))-  (let ((l1_s2376 (xor l1_s288 l1_s2375)))-  (let ((l1_s2377 (ite l1_s2195 l1_s2376 l1_s2375)))-  (let ((l1_s2378 (xor l1_s276 l1_s2377)))-  (let ((l1_s2379 (ite l1_s2227 l1_s2378 l1_s2377)))-  (let ((l1_s2380 (xor l1_s266 l1_s2379)))-  (let ((l1_s2381 (ite l1_s2259 l1_s2380 l1_s2379)))-  (let ((l1_s2382 (xor l1_s258 l1_s2381)))-  (let ((l1_s2383 (ite l1_s2291 l1_s2382 l1_s2381)))-  (let ((l1_s2384 (xor l1_s252 l1_s2383)))-  (let ((l1_s2385 (ite l1_s2323 l1_s2384 l1_s2383)))-  (let ((l1_s2386 (xor l1_s248 l1_s2385)))-  (let ((l1_s2387 (ite l1_s2355 l1_s2386 l1_s2385)))-  (let ((l1_s2388 (xor l1_s4 l1_s180)))-  (let ((l1_s2389 (ite l1_s1907 l1_s2388 l1_s180)))-  (let ((l1_s2390 (xor l1_s486 l1_s2389)))-  (let ((l1_s2391 (ite l1_s1939 l1_s2390 l1_s2389)))-  (let ((l1_s2392 (xor l1_s456 l1_s2391)))-  (let ((l1_s2393 (ite l1_s1971 l1_s2392 l1_s2391)))-  (let ((l1_s2394 (xor l1_s428 l1_s2393)))-  (let ((l1_s2395 (ite l1_s2003 l1_s2394 l1_s2393)))-  (let ((l1_s2396 (xor l1_s402 l1_s2395)))-  (let ((l1_s2397 (ite l1_s2035 l1_s2396 l1_s2395)))-  (let ((l1_s2398 (xor l1_s378 l1_s2397)))-  (let ((l1_s2399 (ite l1_s2067 l1_s2398 l1_s2397)))-  (let ((l1_s2400 (xor l1_s356 l1_s2399)))-  (let ((l1_s2401 (ite l1_s2099 l1_s2400 l1_s2399)))-  (let ((l1_s2402 (xor l1_s336 l1_s2401)))-  (let ((l1_s2403 (ite l1_s2131 l1_s2402 l1_s2401)))-  (let ((l1_s2404 (xor l1_s318 l1_s2403)))-  (let ((l1_s2405 (ite l1_s2163 l1_s2404 l1_s2403)))-  (let ((l1_s2406 (xor l1_s302 l1_s2405)))-  (let ((l1_s2407 (ite l1_s2195 l1_s2406 l1_s2405)))-  (let ((l1_s2408 (xor l1_s288 l1_s2407)))-  (let ((l1_s2409 (ite l1_s2227 l1_s2408 l1_s2407)))-  (let ((l1_s2410 (xor l1_s276 l1_s2409)))-  (let ((l1_s2411 (ite l1_s2259 l1_s2410 l1_s2409)))-  (let ((l1_s2412 (xor l1_s266 l1_s2411)))-  (let ((l1_s2413 (ite l1_s2291 l1_s2412 l1_s2411)))-  (let ((l1_s2414 (xor l1_s258 l1_s2413)))-  (let ((l1_s2415 (ite l1_s2323 l1_s2414 l1_s2413)))-  (let ((l1_s2416 (xor l1_s252 l1_s2415)))-  (let ((l1_s2417 (ite l1_s2355 l1_s2416 l1_s2415)))-  (let ((l1_s2418 (xor l1_s248 l1_s2417)))-  (let ((l1_s2419 (ite l1_s2387 l1_s2418 l1_s2417)))-  (let ((l1_s2420 (xor l1_s4 l1_s185)))-  (let ((l1_s2421 (ite l1_s1939 l1_s2420 l1_s185)))-  (let ((l1_s2422 (xor l1_s486 l1_s2421)))-  (let ((l1_s2423 (ite l1_s1971 l1_s2422 l1_s2421)))-  (let ((l1_s2424 (xor l1_s456 l1_s2423)))-  (let ((l1_s2425 (ite l1_s2003 l1_s2424 l1_s2423)))-  (let ((l1_s2426 (xor l1_s428 l1_s2425)))-  (let ((l1_s2427 (ite l1_s2035 l1_s2426 l1_s2425)))-  (let ((l1_s2428 (xor l1_s402 l1_s2427)))-  (let ((l1_s2429 (ite l1_s2067 l1_s2428 l1_s2427)))-  (let ((l1_s2430 (xor l1_s378 l1_s2429)))-  (let ((l1_s2431 (ite l1_s2099 l1_s2430 l1_s2429)))-  (let ((l1_s2432 (xor l1_s356 l1_s2431)))-  (let ((l1_s2433 (ite l1_s2131 l1_s2432 l1_s2431)))-  (let ((l1_s2434 (xor l1_s336 l1_s2433)))-  (let ((l1_s2435 (ite l1_s2163 l1_s2434 l1_s2433)))-  (let ((l1_s2436 (xor l1_s318 l1_s2435)))-  (let ((l1_s2437 (ite l1_s2195 l1_s2436 l1_s2435)))-  (let ((l1_s2438 (xor l1_s302 l1_s2437)))-  (let ((l1_s2439 (ite l1_s2227 l1_s2438 l1_s2437)))-  (let ((l1_s2440 (xor l1_s288 l1_s2439)))-  (let ((l1_s2441 (ite l1_s2259 l1_s2440 l1_s2439)))-  (let ((l1_s2442 (xor l1_s276 l1_s2441)))-  (let ((l1_s2443 (ite l1_s2291 l1_s2442 l1_s2441)))-  (let ((l1_s2444 (xor l1_s266 l1_s2443)))-  (let ((l1_s2445 (ite l1_s2323 l1_s2444 l1_s2443)))-  (let ((l1_s2446 (xor l1_s258 l1_s2445)))-  (let ((l1_s2447 (ite l1_s2355 l1_s2446 l1_s2445)))-  (let ((l1_s2448 (xor l1_s252 l1_s2447)))-  (let ((l1_s2449 (ite l1_s2387 l1_s2448 l1_s2447)))-  (let ((l1_s2450 (xor l1_s248 l1_s2449)))-  (let ((l1_s2451 (ite l1_s2419 l1_s2450 l1_s2449)))-  (let ((l1_s2452 (xor l1_s4 l1_s190)))-  (let ((l1_s2453 (ite l1_s1971 l1_s2452 l1_s190)))-  (let ((l1_s2454 (xor l1_s486 l1_s2453)))-  (let ((l1_s2455 (ite l1_s2003 l1_s2454 l1_s2453)))-  (let ((l1_s2456 (xor l1_s456 l1_s2455)))-  (let ((l1_s2457 (ite l1_s2035 l1_s2456 l1_s2455)))-  (let ((l1_s2458 (xor l1_s428 l1_s2457)))-  (let ((l1_s2459 (ite l1_s2067 l1_s2458 l1_s2457)))-  (let ((l1_s2460 (xor l1_s402 l1_s2459)))-  (let ((l1_s2461 (ite l1_s2099 l1_s2460 l1_s2459)))-  (let ((l1_s2462 (xor l1_s378 l1_s2461)))-  (let ((l1_s2463 (ite l1_s2131 l1_s2462 l1_s2461)))-  (let ((l1_s2464 (xor l1_s356 l1_s2463)))-  (let ((l1_s2465 (ite l1_s2163 l1_s2464 l1_s2463)))-  (let ((l1_s2466 (xor l1_s336 l1_s2465)))-  (let ((l1_s2467 (ite l1_s2195 l1_s2466 l1_s2465)))-  (let ((l1_s2468 (xor l1_s318 l1_s2467)))-  (let ((l1_s2469 (ite l1_s2227 l1_s2468 l1_s2467)))-  (let ((l1_s2470 (xor l1_s302 l1_s2469)))-  (let ((l1_s2471 (ite l1_s2259 l1_s2470 l1_s2469)))-  (let ((l1_s2472 (xor l1_s288 l1_s2471)))-  (let ((l1_s2473 (ite l1_s2291 l1_s2472 l1_s2471)))-  (let ((l1_s2474 (xor l1_s276 l1_s2473)))-  (let ((l1_s2475 (ite l1_s2323 l1_s2474 l1_s2473)))-  (let ((l1_s2476 (xor l1_s266 l1_s2475)))-  (let ((l1_s2477 (ite l1_s2355 l1_s2476 l1_s2475)))-  (let ((l1_s2478 (xor l1_s258 l1_s2477)))-  (let ((l1_s2479 (ite l1_s2387 l1_s2478 l1_s2477)))-  (let ((l1_s2480 (xor l1_s252 l1_s2479)))-  (let ((l1_s2481 (ite l1_s2419 l1_s2480 l1_s2479)))-  (let ((l1_s2482 (xor l1_s248 l1_s2481)))-  (let ((l1_s2483 (ite l1_s2451 l1_s2482 l1_s2481)))-  (let ((l1_s2484 (xor l1_s4 l1_s195)))-  (let ((l1_s2485 (ite l1_s2003 l1_s2484 l1_s195)))-  (let ((l1_s2486 (xor l1_s486 l1_s2485)))-  (let ((l1_s2487 (ite l1_s2035 l1_s2486 l1_s2485)))-  (let ((l1_s2488 (xor l1_s456 l1_s2487)))-  (let ((l1_s2489 (ite l1_s2067 l1_s2488 l1_s2487)))-  (let ((l1_s2490 (xor l1_s428 l1_s2489)))-  (let ((l1_s2491 (ite l1_s2099 l1_s2490 l1_s2489)))-  (let ((l1_s2492 (xor l1_s402 l1_s2491)))-  (let ((l1_s2493 (ite l1_s2131 l1_s2492 l1_s2491)))-  (let ((l1_s2494 (xor l1_s378 l1_s2493)))-  (let ((l1_s2495 (ite l1_s2163 l1_s2494 l1_s2493)))-  (let ((l1_s2496 (xor l1_s356 l1_s2495)))-  (let ((l1_s2497 (ite l1_s2195 l1_s2496 l1_s2495)))-  (let ((l1_s2498 (xor l1_s336 l1_s2497)))-  (let ((l1_s2499 (ite l1_s2227 l1_s2498 l1_s2497)))-  (let ((l1_s2500 (xor l1_s318 l1_s2499)))-  (let ((l1_s2501 (ite l1_s2259 l1_s2500 l1_s2499)))-  (let ((l1_s2502 (xor l1_s302 l1_s2501)))-  (let ((l1_s2503 (ite l1_s2291 l1_s2502 l1_s2501)))-  (let ((l1_s2504 (xor l1_s288 l1_s2503)))-  (let ((l1_s2505 (ite l1_s2323 l1_s2504 l1_s2503)))-  (let ((l1_s2506 (xor l1_s276 l1_s2505)))-  (let ((l1_s2507 (ite l1_s2355 l1_s2506 l1_s2505)))-  (let ((l1_s2508 (xor l1_s266 l1_s2507)))-  (let ((l1_s2509 (ite l1_s2387 l1_s2508 l1_s2507)))-  (let ((l1_s2510 (xor l1_s258 l1_s2509)))-  (let ((l1_s2511 (ite l1_s2419 l1_s2510 l1_s2509)))-  (let ((l1_s2512 (xor l1_s252 l1_s2511)))-  (let ((l1_s2513 (ite l1_s2451 l1_s2512 l1_s2511)))-  (let ((l1_s2514 (xor l1_s248 l1_s2513)))-  (let ((l1_s2515 (ite l1_s2483 l1_s2514 l1_s2513)))-  (let ((l1_s2516 (xor l1_s4 l1_s200)))-  (let ((l1_s2517 (ite l1_s2035 l1_s2516 l1_s200)))-  (let ((l1_s2518 (xor l1_s486 l1_s2517)))-  (let ((l1_s2519 (ite l1_s2067 l1_s2518 l1_s2517)))-  (let ((l1_s2520 (xor l1_s456 l1_s2519)))-  (let ((l1_s2521 (ite l1_s2099 l1_s2520 l1_s2519)))-  (let ((l1_s2522 (xor l1_s428 l1_s2521)))-  (let ((l1_s2523 (ite l1_s2131 l1_s2522 l1_s2521)))-  (let ((l1_s2524 (xor l1_s402 l1_s2523)))-  (let ((l1_s2525 (ite l1_s2163 l1_s2524 l1_s2523)))-  (let ((l1_s2526 (xor l1_s378 l1_s2525)))-  (let ((l1_s2527 (ite l1_s2195 l1_s2526 l1_s2525)))-  (let ((l1_s2528 (xor l1_s356 l1_s2527)))-  (let ((l1_s2529 (ite l1_s2227 l1_s2528 l1_s2527)))-  (let ((l1_s2530 (xor l1_s336 l1_s2529)))-  (let ((l1_s2531 (ite l1_s2259 l1_s2530 l1_s2529)))-  (let ((l1_s2532 (xor l1_s318 l1_s2531)))-  (let ((l1_s2533 (ite l1_s2291 l1_s2532 l1_s2531)))-  (let ((l1_s2534 (xor l1_s302 l1_s2533)))-  (let ((l1_s2535 (ite l1_s2323 l1_s2534 l1_s2533)))-  (let ((l1_s2536 (xor l1_s288 l1_s2535)))-  (let ((l1_s2537 (ite l1_s2355 l1_s2536 l1_s2535)))-  (let ((l1_s2538 (xor l1_s276 l1_s2537)))-  (let ((l1_s2539 (ite l1_s2387 l1_s2538 l1_s2537)))-  (let ((l1_s2540 (xor l1_s266 l1_s2539)))-  (let ((l1_s2541 (ite l1_s2419 l1_s2540 l1_s2539)))-  (let ((l1_s2542 (xor l1_s258 l1_s2541)))-  (let ((l1_s2543 (ite l1_s2451 l1_s2542 l1_s2541)))-  (let ((l1_s2544 (xor l1_s252 l1_s2543)))-  (let ((l1_s2545 (ite l1_s2483 l1_s2544 l1_s2543)))-  (let ((l1_s2546 (xor l1_s248 l1_s2545)))-  (let ((l1_s2547 (ite l1_s2515 l1_s2546 l1_s2545)))-  (let ((l1_s2548 (xor l1_s4 l1_s205)))-  (let ((l1_s2549 (ite l1_s2067 l1_s2548 l1_s205)))-  (let ((l1_s2550 (xor l1_s486 l1_s2549)))-  (let ((l1_s2551 (ite l1_s2099 l1_s2550 l1_s2549)))-  (let ((l1_s2552 (xor l1_s456 l1_s2551)))-  (let ((l1_s2553 (ite l1_s2131 l1_s2552 l1_s2551)))-  (let ((l1_s2554 (xor l1_s428 l1_s2553)))-  (let ((l1_s2555 (ite l1_s2163 l1_s2554 l1_s2553)))-  (let ((l1_s2556 (xor l1_s402 l1_s2555)))-  (let ((l1_s2557 (ite l1_s2195 l1_s2556 l1_s2555)))-  (let ((l1_s2558 (xor l1_s378 l1_s2557)))-  (let ((l1_s2559 (ite l1_s2227 l1_s2558 l1_s2557)))-  (let ((l1_s2560 (xor l1_s356 l1_s2559)))-  (let ((l1_s2561 (ite l1_s2259 l1_s2560 l1_s2559)))-  (let ((l1_s2562 (xor l1_s336 l1_s2561)))-  (let ((l1_s2563 (ite l1_s2291 l1_s2562 l1_s2561)))-  (let ((l1_s2564 (xor l1_s318 l1_s2563)))-  (let ((l1_s2565 (ite l1_s2323 l1_s2564 l1_s2563)))-  (let ((l1_s2566 (xor l1_s302 l1_s2565)))-  (let ((l1_s2567 (ite l1_s2355 l1_s2566 l1_s2565)))-  (let ((l1_s2568 (xor l1_s288 l1_s2567)))-  (let ((l1_s2569 (ite l1_s2387 l1_s2568 l1_s2567)))-  (let ((l1_s2570 (xor l1_s276 l1_s2569)))-  (let ((l1_s2571 (ite l1_s2419 l1_s2570 l1_s2569)))-  (let ((l1_s2572 (xor l1_s266 l1_s2571)))-  (let ((l1_s2573 (ite l1_s2451 l1_s2572 l1_s2571)))-  (let ((l1_s2574 (xor l1_s258 l1_s2573)))-  (let ((l1_s2575 (ite l1_s2483 l1_s2574 l1_s2573)))-  (let ((l1_s2576 (xor l1_s252 l1_s2575)))-  (let ((l1_s2577 (ite l1_s2515 l1_s2576 l1_s2575)))-  (let ((l1_s2578 (xor l1_s248 l1_s2577)))-  (let ((l1_s2579 (ite l1_s2547 l1_s2578 l1_s2577)))-  (let ((l1_s2580 (xor l1_s4 l1_s210)))-  (let ((l1_s2581 (ite l1_s2099 l1_s2580 l1_s210)))-  (let ((l1_s2582 (xor l1_s486 l1_s2581)))-  (let ((l1_s2583 (ite l1_s2131 l1_s2582 l1_s2581)))-  (let ((l1_s2584 (xor l1_s456 l1_s2583)))-  (let ((l1_s2585 (ite l1_s2163 l1_s2584 l1_s2583)))-  (let ((l1_s2586 (xor l1_s428 l1_s2585)))-  (let ((l1_s2587 (ite l1_s2195 l1_s2586 l1_s2585)))-  (let ((l1_s2588 (xor l1_s402 l1_s2587)))-  (let ((l1_s2589 (ite l1_s2227 l1_s2588 l1_s2587)))-  (let ((l1_s2590 (xor l1_s378 l1_s2589)))-  (let ((l1_s2591 (ite l1_s2259 l1_s2590 l1_s2589)))-  (let ((l1_s2592 (xor l1_s356 l1_s2591)))-  (let ((l1_s2593 (ite l1_s2291 l1_s2592 l1_s2591)))-  (let ((l1_s2594 (xor l1_s336 l1_s2593)))-  (let ((l1_s2595 (ite l1_s2323 l1_s2594 l1_s2593)))-  (let ((l1_s2596 (xor l1_s318 l1_s2595)))-  (let ((l1_s2597 (ite l1_s2355 l1_s2596 l1_s2595)))-  (let ((l1_s2598 (xor l1_s302 l1_s2597)))-  (let ((l1_s2599 (ite l1_s2387 l1_s2598 l1_s2597)))-  (let ((l1_s2600 (xor l1_s288 l1_s2599)))-  (let ((l1_s2601 (ite l1_s2419 l1_s2600 l1_s2599)))-  (let ((l1_s2602 (xor l1_s276 l1_s2601)))-  (let ((l1_s2603 (ite l1_s2451 l1_s2602 l1_s2601)))-  (let ((l1_s2604 (xor l1_s266 l1_s2603)))-  (let ((l1_s2605 (ite l1_s2483 l1_s2604 l1_s2603)))-  (let ((l1_s2606 (xor l1_s258 l1_s2605)))-  (let ((l1_s2607 (ite l1_s2515 l1_s2606 l1_s2605)))-  (let ((l1_s2608 (xor l1_s252 l1_s2607)))-  (let ((l1_s2609 (ite l1_s2547 l1_s2608 l1_s2607)))-  (let ((l1_s2610 (xor l1_s248 l1_s2609)))-  (let ((l1_s2611 (ite l1_s2579 l1_s2610 l1_s2609)))-  (let ((l1_s2612 (xor l1_s4 l1_s215)))-  (let ((l1_s2613 (ite l1_s2131 l1_s2612 l1_s215)))-  (let ((l1_s2614 (xor l1_s486 l1_s2613)))-  (let ((l1_s2615 (ite l1_s2163 l1_s2614 l1_s2613)))-  (let ((l1_s2616 (xor l1_s456 l1_s2615)))-  (let ((l1_s2617 (ite l1_s2195 l1_s2616 l1_s2615)))-  (let ((l1_s2618 (xor l1_s428 l1_s2617)))-  (let ((l1_s2619 (ite l1_s2227 l1_s2618 l1_s2617)))-  (let ((l1_s2620 (xor l1_s402 l1_s2619)))-  (let ((l1_s2621 (ite l1_s2259 l1_s2620 l1_s2619)))-  (let ((l1_s2622 (xor l1_s378 l1_s2621)))-  (let ((l1_s2623 (ite l1_s2291 l1_s2622 l1_s2621)))-  (let ((l1_s2624 (xor l1_s356 l1_s2623)))-  (let ((l1_s2625 (ite l1_s2323 l1_s2624 l1_s2623)))-  (let ((l1_s2626 (xor l1_s336 l1_s2625)))-  (let ((l1_s2627 (ite l1_s2355 l1_s2626 l1_s2625)))-  (let ((l1_s2628 (xor l1_s318 l1_s2627)))-  (let ((l1_s2629 (ite l1_s2387 l1_s2628 l1_s2627)))-  (let ((l1_s2630 (xor l1_s302 l1_s2629)))-  (let ((l1_s2631 (ite l1_s2419 l1_s2630 l1_s2629)))-  (let ((l1_s2632 (xor l1_s288 l1_s2631)))-  (let ((l1_s2633 (ite l1_s2451 l1_s2632 l1_s2631)))-  (let ((l1_s2634 (xor l1_s276 l1_s2633)))-  (let ((l1_s2635 (ite l1_s2483 l1_s2634 l1_s2633)))-  (let ((l1_s2636 (xor l1_s266 l1_s2635)))-  (let ((l1_s2637 (ite l1_s2515 l1_s2636 l1_s2635)))-  (let ((l1_s2638 (xor l1_s258 l1_s2637)))-  (let ((l1_s2639 (ite l1_s2547 l1_s2638 l1_s2637)))-  (let ((l1_s2640 (xor l1_s252 l1_s2639)))-  (let ((l1_s2641 (ite l1_s2579 l1_s2640 l1_s2639)))-  (let ((l1_s2642 (xor l1_s248 l1_s2641)))-  (let ((l1_s2643 (ite l1_s2611 l1_s2642 l1_s2641)))-  (let ((l1_s2644 (xor l1_s4 l1_s220)))-  (let ((l1_s2645 (ite l1_s2163 l1_s2644 l1_s220)))-  (let ((l1_s2646 (xor l1_s486 l1_s2645)))-  (let ((l1_s2647 (ite l1_s2195 l1_s2646 l1_s2645)))-  (let ((l1_s2648 (xor l1_s456 l1_s2647)))-  (let ((l1_s2649 (ite l1_s2227 l1_s2648 l1_s2647)))-  (let ((l1_s2650 (xor l1_s428 l1_s2649)))-  (let ((l1_s2651 (ite l1_s2259 l1_s2650 l1_s2649)))-  (let ((l1_s2652 (xor l1_s402 l1_s2651)))-  (let ((l1_s2653 (ite l1_s2291 l1_s2652 l1_s2651)))-  (let ((l1_s2654 (xor l1_s378 l1_s2653)))-  (let ((l1_s2655 (ite l1_s2323 l1_s2654 l1_s2653)))-  (let ((l1_s2656 (xor l1_s356 l1_s2655)))-  (let ((l1_s2657 (ite l1_s2355 l1_s2656 l1_s2655)))-  (let ((l1_s2658 (xor l1_s336 l1_s2657)))-  (let ((l1_s2659 (ite l1_s2387 l1_s2658 l1_s2657)))-  (let ((l1_s2660 (xor l1_s318 l1_s2659)))-  (let ((l1_s2661 (ite l1_s2419 l1_s2660 l1_s2659)))-  (let ((l1_s2662 (xor l1_s302 l1_s2661)))-  (let ((l1_s2663 (ite l1_s2451 l1_s2662 l1_s2661)))-  (let ((l1_s2664 (xor l1_s288 l1_s2663)))-  (let ((l1_s2665 (ite l1_s2483 l1_s2664 l1_s2663)))-  (let ((l1_s2666 (xor l1_s276 l1_s2665)))-  (let ((l1_s2667 (ite l1_s2515 l1_s2666 l1_s2665)))-  (let ((l1_s2668 (xor l1_s266 l1_s2667)))-  (let ((l1_s2669 (ite l1_s2547 l1_s2668 l1_s2667)))-  (let ((l1_s2670 (xor l1_s258 l1_s2669)))-  (let ((l1_s2671 (ite l1_s2579 l1_s2670 l1_s2669)))-  (let ((l1_s2672 (xor l1_s252 l1_s2671)))-  (let ((l1_s2673 (ite l1_s2611 l1_s2672 l1_s2671)))-  (let ((l1_s2674 (xor l1_s248 l1_s2673)))-  (let ((l1_s2675 (ite l1_s2643 l1_s2674 l1_s2673)))-  (let ((l1_s2676 (xor l1_s4 l1_s225)))-  (let ((l1_s2677 (ite l1_s2195 l1_s2676 l1_s225)))-  (let ((l1_s2678 (xor l1_s486 l1_s2677)))-  (let ((l1_s2679 (ite l1_s2227 l1_s2678 l1_s2677)))-  (let ((l1_s2680 (xor l1_s456 l1_s2679)))-  (let ((l1_s2681 (ite l1_s2259 l1_s2680 l1_s2679)))-  (let ((l1_s2682 (xor l1_s428 l1_s2681)))-  (let ((l1_s2683 (ite l1_s2291 l1_s2682 l1_s2681)))-  (let ((l1_s2684 (xor l1_s402 l1_s2683)))-  (let ((l1_s2685 (ite l1_s2323 l1_s2684 l1_s2683)))-  (let ((l1_s2686 (xor l1_s378 l1_s2685)))-  (let ((l1_s2687 (ite l1_s2355 l1_s2686 l1_s2685)))-  (let ((l1_s2688 (xor l1_s356 l1_s2687)))-  (let ((l1_s2689 (ite l1_s2387 l1_s2688 l1_s2687)))-  (let ((l1_s2690 (xor l1_s336 l1_s2689)))-  (let ((l1_s2691 (ite l1_s2419 l1_s2690 l1_s2689)))-  (let ((l1_s2692 (xor l1_s318 l1_s2691)))-  (let ((l1_s2693 (ite l1_s2451 l1_s2692 l1_s2691)))-  (let ((l1_s2694 (xor l1_s302 l1_s2693)))-  (let ((l1_s2695 (ite l1_s2483 l1_s2694 l1_s2693)))-  (let ((l1_s2696 (xor l1_s288 l1_s2695)))-  (let ((l1_s2697 (ite l1_s2515 l1_s2696 l1_s2695)))-  (let ((l1_s2698 (xor l1_s276 l1_s2697)))-  (let ((l1_s2699 (ite l1_s2547 l1_s2698 l1_s2697)))-  (let ((l1_s2700 (xor l1_s266 l1_s2699)))-  (let ((l1_s2701 (ite l1_s2579 l1_s2700 l1_s2699)))-  (let ((l1_s2702 (xor l1_s258 l1_s2701)))-  (let ((l1_s2703 (ite l1_s2611 l1_s2702 l1_s2701)))-  (let ((l1_s2704 (xor l1_s252 l1_s2703)))-  (let ((l1_s2705 (ite l1_s2643 l1_s2704 l1_s2703)))-  (let ((l1_s2706 (xor l1_s248 l1_s2705)))-  (let ((l1_s2707 (ite l1_s2675 l1_s2706 l1_s2705)))-  (let ((l1_s2708 (xor l1_s4 l1_s230)))-  (let ((l1_s2709 (ite l1_s2227 l1_s2708 l1_s230)))-  (let ((l1_s2710 (xor l1_s486 l1_s2709)))-  (let ((l1_s2711 (ite l1_s2259 l1_s2710 l1_s2709)))-  (let ((l1_s2712 (xor l1_s456 l1_s2711)))-  (let ((l1_s2713 (ite l1_s2291 l1_s2712 l1_s2711)))-  (let ((l1_s2714 (xor l1_s428 l1_s2713)))-  (let ((l1_s2715 (ite l1_s2323 l1_s2714 l1_s2713)))-  (let ((l1_s2716 (xor l1_s402 l1_s2715)))-  (let ((l1_s2717 (ite l1_s2355 l1_s2716 l1_s2715)))-  (let ((l1_s2718 (xor l1_s378 l1_s2717)))-  (let ((l1_s2719 (ite l1_s2387 l1_s2718 l1_s2717)))-  (let ((l1_s2720 (xor l1_s356 l1_s2719)))-  (let ((l1_s2721 (ite l1_s2419 l1_s2720 l1_s2719)))-  (let ((l1_s2722 (xor l1_s336 l1_s2721)))-  (let ((l1_s2723 (ite l1_s2451 l1_s2722 l1_s2721)))-  (let ((l1_s2724 (xor l1_s318 l1_s2723)))-  (let ((l1_s2725 (ite l1_s2483 l1_s2724 l1_s2723)))-  (let ((l1_s2726 (xor l1_s302 l1_s2725)))-  (let ((l1_s2727 (ite l1_s2515 l1_s2726 l1_s2725)))-  (let ((l1_s2728 (xor l1_s288 l1_s2727)))-  (let ((l1_s2729 (ite l1_s2547 l1_s2728 l1_s2727)))-  (let ((l1_s2730 (xor l1_s276 l1_s2729)))-  (let ((l1_s2731 (ite l1_s2579 l1_s2730 l1_s2729)))-  (let ((l1_s2732 (xor l1_s266 l1_s2731)))-  (let ((l1_s2733 (ite l1_s2611 l1_s2732 l1_s2731)))-  (let ((l1_s2734 (xor l1_s258 l1_s2733)))-  (let ((l1_s2735 (ite l1_s2643 l1_s2734 l1_s2733)))-  (let ((l1_s2736 (xor l1_s252 l1_s2735)))-  (let ((l1_s2737 (ite l1_s2675 l1_s2736 l1_s2735)))-  (let ((l1_s2738 (xor l1_s248 l1_s2737)))-  (let ((l1_s2739 (ite l1_s2707 l1_s2738 l1_s2737)))-  (let ((l1_s2740 (xor l1_s4 l1_s235)))-  (let ((l1_s2741 (ite l1_s2259 l1_s2740 l1_s235)))-  (let ((l1_s2742 (xor l1_s486 l1_s2741)))-  (let ((l1_s2743 (ite l1_s2291 l1_s2742 l1_s2741)))-  (let ((l1_s2744 (xor l1_s456 l1_s2743)))-  (let ((l1_s2745 (ite l1_s2323 l1_s2744 l1_s2743)))-  (let ((l1_s2746 (xor l1_s428 l1_s2745)))-  (let ((l1_s2747 (ite l1_s2355 l1_s2746 l1_s2745)))-  (let ((l1_s2748 (xor l1_s402 l1_s2747)))-  (let ((l1_s2749 (ite l1_s2387 l1_s2748 l1_s2747)))-  (let ((l1_s2750 (xor l1_s378 l1_s2749)))-  (let ((l1_s2751 (ite l1_s2419 l1_s2750 l1_s2749)))-  (let ((l1_s2752 (xor l1_s356 l1_s2751)))-  (let ((l1_s2753 (ite l1_s2451 l1_s2752 l1_s2751)))-  (let ((l1_s2754 (xor l1_s336 l1_s2753)))-  (let ((l1_s2755 (ite l1_s2483 l1_s2754 l1_s2753)))-  (let ((l1_s2756 (xor l1_s318 l1_s2755)))-  (let ((l1_s2757 (ite l1_s2515 l1_s2756 l1_s2755)))-  (let ((l1_s2758 (xor l1_s302 l1_s2757)))-  (let ((l1_s2759 (ite l1_s2547 l1_s2758 l1_s2757)))-  (let ((l1_s2760 (xor l1_s288 l1_s2759)))-  (let ((l1_s2761 (ite l1_s2579 l1_s2760 l1_s2759)))-  (let ((l1_s2762 (xor l1_s276 l1_s2761)))-  (let ((l1_s2763 (ite l1_s2611 l1_s2762 l1_s2761)))-  (let ((l1_s2764 (xor l1_s266 l1_s2763)))-  (let ((l1_s2765 (ite l1_s2643 l1_s2764 l1_s2763)))-  (let ((l1_s2766 (xor l1_s258 l1_s2765)))-  (let ((l1_s2767 (ite l1_s2675 l1_s2766 l1_s2765)))-  (let ((l1_s2768 (xor l1_s252 l1_s2767)))-  (let ((l1_s2769 (ite l1_s2707 l1_s2768 l1_s2767)))-  (let ((l1_s2770 (xor l1_s248 l1_s2769)))-  (let ((l1_s2771 (ite l1_s2739 l1_s2770 l1_s2769)))-  (let ((l1_s2772 (xor l1_s4 l1_s240)))-  (let ((l1_s2773 (ite l1_s2291 l1_s2772 l1_s240)))-  (let ((l1_s2774 (xor l1_s486 l1_s2773)))-  (let ((l1_s2775 (ite l1_s2323 l1_s2774 l1_s2773)))-  (let ((l1_s2776 (xor l1_s456 l1_s2775)))-  (let ((l1_s2777 (ite l1_s2355 l1_s2776 l1_s2775)))-  (let ((l1_s2778 (xor l1_s428 l1_s2777)))-  (let ((l1_s2779 (ite l1_s2387 l1_s2778 l1_s2777)))-  (let ((l1_s2780 (xor l1_s402 l1_s2779)))-  (let ((l1_s2781 (ite l1_s2419 l1_s2780 l1_s2779)))-  (let ((l1_s2782 (xor l1_s378 l1_s2781)))-  (let ((l1_s2783 (ite l1_s2451 l1_s2782 l1_s2781)))-  (let ((l1_s2784 (xor l1_s356 l1_s2783)))-  (let ((l1_s2785 (ite l1_s2483 l1_s2784 l1_s2783)))-  (let ((l1_s2786 (xor l1_s336 l1_s2785)))-  (let ((l1_s2787 (ite l1_s2515 l1_s2786 l1_s2785)))-  (let ((l1_s2788 (xor l1_s318 l1_s2787)))-  (let ((l1_s2789 (ite l1_s2547 l1_s2788 l1_s2787)))-  (let ((l1_s2790 (xor l1_s302 l1_s2789)))-  (let ((l1_s2791 (ite l1_s2579 l1_s2790 l1_s2789)))-  (let ((l1_s2792 (xor l1_s288 l1_s2791)))-  (let ((l1_s2793 (ite l1_s2611 l1_s2792 l1_s2791)))-  (let ((l1_s2794 (xor l1_s276 l1_s2793)))-  (let ((l1_s2795 (ite l1_s2643 l1_s2794 l1_s2793)))-  (let ((l1_s2796 (xor l1_s266 l1_s2795)))-  (let ((l1_s2797 (ite l1_s2675 l1_s2796 l1_s2795)))-  (let ((l1_s2798 (xor l1_s258 l1_s2797)))-  (let ((l1_s2799 (ite l1_s2707 l1_s2798 l1_s2797)))-  (let ((l1_s2800 (xor l1_s252 l1_s2799)))-  (let ((l1_s2801 (ite l1_s2739 l1_s2800 l1_s2799)))-  (let ((l1_s2802 (xor l1_s248 l1_s2801)))-  (let ((l1_s2803 (ite l1_s2771 l1_s2802 l1_s2801)))-  (let ((l1_s2804 (xor l1_s4 l1_s245)))-  (let ((l1_s2805 (ite l1_s2323 l1_s2804 l1_s245)))-  (let ((l1_s2806 (xor l1_s486 l1_s2805)))-  (let ((l1_s2807 (ite l1_s2355 l1_s2806 l1_s2805)))-  (let ((l1_s2808 (xor l1_s456 l1_s2807)))-  (let ((l1_s2809 (ite l1_s2387 l1_s2808 l1_s2807)))-  (let ((l1_s2810 (xor l1_s428 l1_s2809)))-  (let ((l1_s2811 (ite l1_s2419 l1_s2810 l1_s2809)))-  (let ((l1_s2812 (xor l1_s402 l1_s2811)))-  (let ((l1_s2813 (ite l1_s2451 l1_s2812 l1_s2811)))-  (let ((l1_s2814 (xor l1_s378 l1_s2813)))-  (let ((l1_s2815 (ite l1_s2483 l1_s2814 l1_s2813)))-  (let ((l1_s2816 (xor l1_s356 l1_s2815)))-  (let ((l1_s2817 (ite l1_s2515 l1_s2816 l1_s2815)))-  (let ((l1_s2818 (xor l1_s336 l1_s2817)))-  (let ((l1_s2819 (ite l1_s2547 l1_s2818 l1_s2817)))-  (let ((l1_s2820 (xor l1_s318 l1_s2819)))-  (let ((l1_s2821 (ite l1_s2579 l1_s2820 l1_s2819)))-  (let ((l1_s2822 (xor l1_s302 l1_s2821)))-  (let ((l1_s2823 (ite l1_s2611 l1_s2822 l1_s2821)))-  (let ((l1_s2824 (xor l1_s288 l1_s2823)))-  (let ((l1_s2825 (ite l1_s2643 l1_s2824 l1_s2823)))-  (let ((l1_s2826 (xor l1_s276 l1_s2825)))-  (let ((l1_s2827 (ite l1_s2675 l1_s2826 l1_s2825)))-  (let ((l1_s2828 (xor l1_s266 l1_s2827)))-  (let ((l1_s2829 (ite l1_s2707 l1_s2828 l1_s2827)))-  (let ((l1_s2830 (xor l1_s258 l1_s2829)))-  (let ((l1_s2831 (ite l1_s2739 l1_s2830 l1_s2829)))-  (let ((l1_s2832 (xor l1_s252 l1_s2831)))-  (let ((l1_s2833 (ite l1_s2771 l1_s2832 l1_s2831)))-  (let ((l1_s2834 (xor l1_s248 l1_s2833)))-  (let ((l1_s2835 (ite l1_s2803 l1_s2834 l1_s2833)))-  (let ((l1_s2836 (and l1_s4 l1_s2355)))-  (let ((l1_s2837 (xor l1_s486 l1_s2836)))-  (let ((l1_s2838 (ite l1_s2387 l1_s2837 l1_s2836)))-  (let ((l1_s2839 (xor l1_s456 l1_s2838)))-  (let ((l1_s2840 (ite l1_s2419 l1_s2839 l1_s2838)))-  (let ((l1_s2841 (xor l1_s428 l1_s2840)))-  (let ((l1_s2842 (ite l1_s2451 l1_s2841 l1_s2840)))-  (let ((l1_s2843 (xor l1_s402 l1_s2842)))-  (let ((l1_s2844 (ite l1_s2483 l1_s2843 l1_s2842)))-  (let ((l1_s2845 (xor l1_s378 l1_s2844)))-  (let ((l1_s2846 (ite l1_s2515 l1_s2845 l1_s2844)))-  (let ((l1_s2847 (xor l1_s356 l1_s2846)))-  (let ((l1_s2848 (ite l1_s2547 l1_s2847 l1_s2846)))-  (let ((l1_s2849 (xor l1_s336 l1_s2848)))-  (let ((l1_s2850 (ite l1_s2579 l1_s2849 l1_s2848)))-  (let ((l1_s2851 (xor l1_s318 l1_s2850)))-  (let ((l1_s2852 (ite l1_s2611 l1_s2851 l1_s2850)))-  (let ((l1_s2853 (xor l1_s302 l1_s2852)))-  (let ((l1_s2854 (ite l1_s2643 l1_s2853 l1_s2852)))-  (let ((l1_s2855 (xor l1_s288 l1_s2854)))-  (let ((l1_s2856 (ite l1_s2675 l1_s2855 l1_s2854)))-  (let ((l1_s2857 (xor l1_s276 l1_s2856)))-  (let ((l1_s2858 (ite l1_s2707 l1_s2857 l1_s2856)))-  (let ((l1_s2859 (xor l1_s266 l1_s2858)))-  (let ((l1_s2860 (ite l1_s2739 l1_s2859 l1_s2858)))-  (let ((l1_s2861 (xor l1_s258 l1_s2860)))-  (let ((l1_s2862 (ite l1_s2771 l1_s2861 l1_s2860)))-  (let ((l1_s2863 (xor l1_s252 l1_s2862)))-  (let ((l1_s2864 (ite l1_s2803 l1_s2863 l1_s2862)))-  (let ((l1_s2865 (xor l1_s248 l1_s2864)))-  (let ((l1_s2866 (ite l1_s2835 l1_s2865 l1_s2864)))-  (let ((l1_s2867 (xor l1_s1571 l1_s2866)))-  (let ((l1_s2868 (and l1_s4 l1_s1092)))-  (let ((l1_s2869 (xor l1_s486 l1_s2868)))-  (let ((l1_s2870 (ite l1_s1124 l1_s2869 l1_s2868)))-  (let ((l1_s2871 (xor l1_s456 l1_s2870)))-  (let ((l1_s2872 (ite l1_s1156 l1_s2871 l1_s2870)))-  (let ((l1_s2873 (xor l1_s428 l1_s2872)))-  (let ((l1_s2874 (ite l1_s1188 l1_s2873 l1_s2872)))-  (let ((l1_s2875 (xor l1_s402 l1_s2874)))-  (let ((l1_s2876 (ite l1_s1220 l1_s2875 l1_s2874)))-  (let ((l1_s2877 (xor l1_s378 l1_s2876)))-  (let ((l1_s2878 (ite l1_s1252 l1_s2877 l1_s2876)))-  (let ((l1_s2879 (xor l1_s356 l1_s2878)))-  (let ((l1_s2880 (ite l1_s1284 l1_s2879 l1_s2878)))-  (let ((l1_s2881 (xor l1_s336 l1_s2880)))-  (let ((l1_s2882 (ite l1_s1316 l1_s2881 l1_s2880)))-  (let ((l1_s2883 (xor l1_s318 l1_s2882)))-  (let ((l1_s2884 (ite l1_s1348 l1_s2883 l1_s2882)))-  (let ((l1_s2885 (xor l1_s302 l1_s2884)))-  (let ((l1_s2886 (ite l1_s1380 l1_s2885 l1_s2884)))-  (let ((l1_s2887 (xor l1_s288 l1_s2886)))-  (let ((l1_s2888 (ite l1_s1412 l1_s2887 l1_s2886)))-  (let ((l1_s2889 (xor l1_s276 l1_s2888)))-  (let ((l1_s2890 (ite l1_s1444 l1_s2889 l1_s2888)))-  (let ((l1_s2891 (xor l1_s266 l1_s2890)))-  (let ((l1_s2892 (ite l1_s1476 l1_s2891 l1_s2890)))-  (let ((l1_s2893 (xor l1_s258 l1_s2892)))-  (let ((l1_s2894 (ite l1_s1508 l1_s2893 l1_s2892)))-  (let ((l1_s2895 (xor l1_s252 l1_s2894)))-  (let ((l1_s2896 (ite l1_s1540 l1_s2895 l1_s2894)))-  (let ((l1_s2897 (and l1_s4 l1_s2387)))-  (let ((l1_s2898 (xor l1_s486 l1_s2897)))-  (let ((l1_s2899 (ite l1_s2419 l1_s2898 l1_s2897)))-  (let ((l1_s2900 (xor l1_s456 l1_s2899)))-  (let ((l1_s2901 (ite l1_s2451 l1_s2900 l1_s2899)))-  (let ((l1_s2902 (xor l1_s428 l1_s2901)))-  (let ((l1_s2903 (ite l1_s2483 l1_s2902 l1_s2901)))-  (let ((l1_s2904 (xor l1_s402 l1_s2903)))-  (let ((l1_s2905 (ite l1_s2515 l1_s2904 l1_s2903)))-  (let ((l1_s2906 (xor l1_s378 l1_s2905)))-  (let ((l1_s2907 (ite l1_s2547 l1_s2906 l1_s2905)))-  (let ((l1_s2908 (xor l1_s356 l1_s2907)))-  (let ((l1_s2909 (ite l1_s2579 l1_s2908 l1_s2907)))-  (let ((l1_s2910 (xor l1_s336 l1_s2909)))-  (let ((l1_s2911 (ite l1_s2611 l1_s2910 l1_s2909)))-  (let ((l1_s2912 (xor l1_s318 l1_s2911)))-  (let ((l1_s2913 (ite l1_s2643 l1_s2912 l1_s2911)))-  (let ((l1_s2914 (xor l1_s302 l1_s2913)))-  (let ((l1_s2915 (ite l1_s2675 l1_s2914 l1_s2913)))-  (let ((l1_s2916 (xor l1_s288 l1_s2915)))-  (let ((l1_s2917 (ite l1_s2707 l1_s2916 l1_s2915)))-  (let ((l1_s2918 (xor l1_s276 l1_s2917)))-  (let ((l1_s2919 (ite l1_s2739 l1_s2918 l1_s2917)))-  (let ((l1_s2920 (xor l1_s266 l1_s2919)))-  (let ((l1_s2921 (ite l1_s2771 l1_s2920 l1_s2919)))-  (let ((l1_s2922 (xor l1_s258 l1_s2921)))-  (let ((l1_s2923 (ite l1_s2803 l1_s2922 l1_s2921)))-  (let ((l1_s2924 (xor l1_s252 l1_s2923)))-  (let ((l1_s2925 (ite l1_s2835 l1_s2924 l1_s2923)))-  (let ((l1_s2926 (xor l1_s2896 l1_s2925)))-  (let ((l1_s2927 (and l1_s4 l1_s1124)))-  (let ((l1_s2928 (xor l1_s486 l1_s2927)))-  (let ((l1_s2929 (ite l1_s1156 l1_s2928 l1_s2927)))-  (let ((l1_s2930 (xor l1_s456 l1_s2929)))-  (let ((l1_s2931 (ite l1_s1188 l1_s2930 l1_s2929)))-  (let ((l1_s2932 (xor l1_s428 l1_s2931)))-  (let ((l1_s2933 (ite l1_s1220 l1_s2932 l1_s2931)))-  (let ((l1_s2934 (xor l1_s402 l1_s2933)))-  (let ((l1_s2935 (ite l1_s1252 l1_s2934 l1_s2933)))-  (let ((l1_s2936 (xor l1_s378 l1_s2935)))-  (let ((l1_s2937 (ite l1_s1284 l1_s2936 l1_s2935)))-  (let ((l1_s2938 (xor l1_s356 l1_s2937)))-  (let ((l1_s2939 (ite l1_s1316 l1_s2938 l1_s2937)))-  (let ((l1_s2940 (xor l1_s336 l1_s2939)))-  (let ((l1_s2941 (ite l1_s1348 l1_s2940 l1_s2939)))-  (let ((l1_s2942 (xor l1_s318 l1_s2941)))-  (let ((l1_s2943 (ite l1_s1380 l1_s2942 l1_s2941)))-  (let ((l1_s2944 (xor l1_s302 l1_s2943)))-  (let ((l1_s2945 (ite l1_s1412 l1_s2944 l1_s2943)))-  (let ((l1_s2946 (xor l1_s288 l1_s2945)))-  (let ((l1_s2947 (ite l1_s1444 l1_s2946 l1_s2945)))-  (let ((l1_s2948 (xor l1_s276 l1_s2947)))-  (let ((l1_s2949 (ite l1_s1476 l1_s2948 l1_s2947)))-  (let ((l1_s2950 (xor l1_s266 l1_s2949)))-  (let ((l1_s2951 (ite l1_s1508 l1_s2950 l1_s2949)))-  (let ((l1_s2952 (xor l1_s258 l1_s2951)))-  (let ((l1_s2953 (ite l1_s1540 l1_s2952 l1_s2951)))-  (let ((l1_s2954 (and l1_s4 l1_s2419)))-  (let ((l1_s2955 (xor l1_s486 l1_s2954)))-  (let ((l1_s2956 (ite l1_s2451 l1_s2955 l1_s2954)))-  (let ((l1_s2957 (xor l1_s456 l1_s2956)))-  (let ((l1_s2958 (ite l1_s2483 l1_s2957 l1_s2956)))-  (let ((l1_s2959 (xor l1_s428 l1_s2958)))-  (let ((l1_s2960 (ite l1_s2515 l1_s2959 l1_s2958)))-  (let ((l1_s2961 (xor l1_s402 l1_s2960)))-  (let ((l1_s2962 (ite l1_s2547 l1_s2961 l1_s2960)))-  (let ((l1_s2963 (xor l1_s378 l1_s2962)))-  (let ((l1_s2964 (ite l1_s2579 l1_s2963 l1_s2962)))-  (let ((l1_s2965 (xor l1_s356 l1_s2964)))-  (let ((l1_s2966 (ite l1_s2611 l1_s2965 l1_s2964)))-  (let ((l1_s2967 (xor l1_s336 l1_s2966)))-  (let ((l1_s2968 (ite l1_s2643 l1_s2967 l1_s2966)))-  (let ((l1_s2969 (xor l1_s318 l1_s2968)))-  (let ((l1_s2970 (ite l1_s2675 l1_s2969 l1_s2968)))-  (let ((l1_s2971 (xor l1_s302 l1_s2970)))-  (let ((l1_s2972 (ite l1_s2707 l1_s2971 l1_s2970)))-  (let ((l1_s2973 (xor l1_s288 l1_s2972)))-  (let ((l1_s2974 (ite l1_s2739 l1_s2973 l1_s2972)))-  (let ((l1_s2975 (xor l1_s276 l1_s2974)))-  (let ((l1_s2976 (ite l1_s2771 l1_s2975 l1_s2974)))-  (let ((l1_s2977 (xor l1_s266 l1_s2976)))-  (let ((l1_s2978 (ite l1_s2803 l1_s2977 l1_s2976)))-  (let ((l1_s2979 (xor l1_s258 l1_s2978)))-  (let ((l1_s2980 (ite l1_s2835 l1_s2979 l1_s2978)))-  (let ((l1_s2981 (xor l1_s2953 l1_s2980)))-  (let ((l1_s2982 (and l1_s4 l1_s1156)))-  (let ((l1_s2983 (xor l1_s486 l1_s2982)))-  (let ((l1_s2984 (ite l1_s1188 l1_s2983 l1_s2982)))-  (let ((l1_s2985 (xor l1_s456 l1_s2984)))-  (let ((l1_s2986 (ite l1_s1220 l1_s2985 l1_s2984)))-  (let ((l1_s2987 (xor l1_s428 l1_s2986)))-  (let ((l1_s2988 (ite l1_s1252 l1_s2987 l1_s2986)))-  (let ((l1_s2989 (xor l1_s402 l1_s2988)))-  (let ((l1_s2990 (ite l1_s1284 l1_s2989 l1_s2988)))-  (let ((l1_s2991 (xor l1_s378 l1_s2990)))-  (let ((l1_s2992 (ite l1_s1316 l1_s2991 l1_s2990)))-  (let ((l1_s2993 (xor l1_s356 l1_s2992)))-  (let ((l1_s2994 (ite l1_s1348 l1_s2993 l1_s2992)))-  (let ((l1_s2995 (xor l1_s336 l1_s2994)))-  (let ((l1_s2996 (ite l1_s1380 l1_s2995 l1_s2994)))-  (let ((l1_s2997 (xor l1_s318 l1_s2996)))-  (let ((l1_s2998 (ite l1_s1412 l1_s2997 l1_s2996)))-  (let ((l1_s2999 (xor l1_s302 l1_s2998)))-  (let ((l1_s3000 (ite l1_s1444 l1_s2999 l1_s2998)))-  (let ((l1_s3001 (xor l1_s288 l1_s3000)))-  (let ((l1_s3002 (ite l1_s1476 l1_s3001 l1_s3000)))-  (let ((l1_s3003 (xor l1_s276 l1_s3002)))-  (let ((l1_s3004 (ite l1_s1508 l1_s3003 l1_s3002)))-  (let ((l1_s3005 (xor l1_s266 l1_s3004)))-  (let ((l1_s3006 (ite l1_s1540 l1_s3005 l1_s3004)))-  (let ((l1_s3007 (and l1_s4 l1_s2451)))-  (let ((l1_s3008 (xor l1_s486 l1_s3007)))-  (let ((l1_s3009 (ite l1_s2483 l1_s3008 l1_s3007)))-  (let ((l1_s3010 (xor l1_s456 l1_s3009)))-  (let ((l1_s3011 (ite l1_s2515 l1_s3010 l1_s3009)))-  (let ((l1_s3012 (xor l1_s428 l1_s3011)))-  (let ((l1_s3013 (ite l1_s2547 l1_s3012 l1_s3011)))-  (let ((l1_s3014 (xor l1_s402 l1_s3013)))-  (let ((l1_s3015 (ite l1_s2579 l1_s3014 l1_s3013)))-  (let ((l1_s3016 (xor l1_s378 l1_s3015)))-  (let ((l1_s3017 (ite l1_s2611 l1_s3016 l1_s3015)))-  (let ((l1_s3018 (xor l1_s356 l1_s3017)))-  (let ((l1_s3019 (ite l1_s2643 l1_s3018 l1_s3017)))-  (let ((l1_s3020 (xor l1_s336 l1_s3019)))-  (let ((l1_s3021 (ite l1_s2675 l1_s3020 l1_s3019)))-  (let ((l1_s3022 (xor l1_s318 l1_s3021)))-  (let ((l1_s3023 (ite l1_s2707 l1_s3022 l1_s3021)))-  (let ((l1_s3024 (xor l1_s302 l1_s3023)))-  (let ((l1_s3025 (ite l1_s2739 l1_s3024 l1_s3023)))-  (let ((l1_s3026 (xor l1_s288 l1_s3025)))-  (let ((l1_s3027 (ite l1_s2771 l1_s3026 l1_s3025)))-  (let ((l1_s3028 (xor l1_s276 l1_s3027)))-  (let ((l1_s3029 (ite l1_s2803 l1_s3028 l1_s3027)))-  (let ((l1_s3030 (xor l1_s266 l1_s3029)))-  (let ((l1_s3031 (ite l1_s2835 l1_s3030 l1_s3029)))-  (let ((l1_s3032 (xor l1_s3006 l1_s3031)))-  (let ((l1_s3033 (and l1_s4 l1_s1188)))-  (let ((l1_s3034 (xor l1_s486 l1_s3033)))-  (let ((l1_s3035 (ite l1_s1220 l1_s3034 l1_s3033)))-  (let ((l1_s3036 (xor l1_s456 l1_s3035)))-  (let ((l1_s3037 (ite l1_s1252 l1_s3036 l1_s3035)))-  (let ((l1_s3038 (xor l1_s428 l1_s3037)))-  (let ((l1_s3039 (ite l1_s1284 l1_s3038 l1_s3037)))-  (let ((l1_s3040 (xor l1_s402 l1_s3039)))-  (let ((l1_s3041 (ite l1_s1316 l1_s3040 l1_s3039)))-  (let ((l1_s3042 (xor l1_s378 l1_s3041)))-  (let ((l1_s3043 (ite l1_s1348 l1_s3042 l1_s3041)))-  (let ((l1_s3044 (xor l1_s356 l1_s3043)))-  (let ((l1_s3045 (ite l1_s1380 l1_s3044 l1_s3043)))-  (let ((l1_s3046 (xor l1_s336 l1_s3045)))-  (let ((l1_s3047 (ite l1_s1412 l1_s3046 l1_s3045)))-  (let ((l1_s3048 (xor l1_s318 l1_s3047)))-  (let ((l1_s3049 (ite l1_s1444 l1_s3048 l1_s3047)))-  (let ((l1_s3050 (xor l1_s302 l1_s3049)))-  (let ((l1_s3051 (ite l1_s1476 l1_s3050 l1_s3049)))-  (let ((l1_s3052 (xor l1_s288 l1_s3051)))-  (let ((l1_s3053 (ite l1_s1508 l1_s3052 l1_s3051)))-  (let ((l1_s3054 (xor l1_s276 l1_s3053)))-  (let ((l1_s3055 (ite l1_s1540 l1_s3054 l1_s3053)))-  (let ((l1_s3056 (and l1_s4 l1_s2483)))-  (let ((l1_s3057 (xor l1_s486 l1_s3056)))-  (let ((l1_s3058 (ite l1_s2515 l1_s3057 l1_s3056)))-  (let ((l1_s3059 (xor l1_s456 l1_s3058)))-  (let ((l1_s3060 (ite l1_s2547 l1_s3059 l1_s3058)))-  (let ((l1_s3061 (xor l1_s428 l1_s3060)))-  (let ((l1_s3062 (ite l1_s2579 l1_s3061 l1_s3060)))-  (let ((l1_s3063 (xor l1_s402 l1_s3062)))-  (let ((l1_s3064 (ite l1_s2611 l1_s3063 l1_s3062)))-  (let ((l1_s3065 (xor l1_s378 l1_s3064)))-  (let ((l1_s3066 (ite l1_s2643 l1_s3065 l1_s3064)))-  (let ((l1_s3067 (xor l1_s356 l1_s3066)))-  (let ((l1_s3068 (ite l1_s2675 l1_s3067 l1_s3066)))-  (let ((l1_s3069 (xor l1_s336 l1_s3068)))-  (let ((l1_s3070 (ite l1_s2707 l1_s3069 l1_s3068)))-  (let ((l1_s3071 (xor l1_s318 l1_s3070)))-  (let ((l1_s3072 (ite l1_s2739 l1_s3071 l1_s3070)))-  (let ((l1_s3073 (xor l1_s302 l1_s3072)))-  (let ((l1_s3074 (ite l1_s2771 l1_s3073 l1_s3072)))-  (let ((l1_s3075 (xor l1_s288 l1_s3074)))-  (let ((l1_s3076 (ite l1_s2803 l1_s3075 l1_s3074)))-  (let ((l1_s3077 (xor l1_s276 l1_s3076)))-  (let ((l1_s3078 (ite l1_s2835 l1_s3077 l1_s3076)))-  (let ((l1_s3079 (xor l1_s3055 l1_s3078)))-  (let ((l1_s3080 (and l1_s4 l1_s1220)))-  (let ((l1_s3081 (xor l1_s486 l1_s3080)))-  (let ((l1_s3082 (ite l1_s1252 l1_s3081 l1_s3080)))-  (let ((l1_s3083 (xor l1_s456 l1_s3082)))-  (let ((l1_s3084 (ite l1_s1284 l1_s3083 l1_s3082)))-  (let ((l1_s3085 (xor l1_s428 l1_s3084)))-  (let ((l1_s3086 (ite l1_s1316 l1_s3085 l1_s3084)))-  (let ((l1_s3087 (xor l1_s402 l1_s3086)))-  (let ((l1_s3088 (ite l1_s1348 l1_s3087 l1_s3086)))-  (let ((l1_s3089 (xor l1_s378 l1_s3088)))-  (let ((l1_s3090 (ite l1_s1380 l1_s3089 l1_s3088)))-  (let ((l1_s3091 (xor l1_s356 l1_s3090)))-  (let ((l1_s3092 (ite l1_s1412 l1_s3091 l1_s3090)))-  (let ((l1_s3093 (xor l1_s336 l1_s3092)))-  (let ((l1_s3094 (ite l1_s1444 l1_s3093 l1_s3092)))-  (let ((l1_s3095 (xor l1_s318 l1_s3094)))-  (let ((l1_s3096 (ite l1_s1476 l1_s3095 l1_s3094)))-  (let ((l1_s3097 (xor l1_s302 l1_s3096)))-  (let ((l1_s3098 (ite l1_s1508 l1_s3097 l1_s3096)))-  (let ((l1_s3099 (xor l1_s288 l1_s3098)))-  (let ((l1_s3100 (ite l1_s1540 l1_s3099 l1_s3098)))-  (let ((l1_s3101 (and l1_s4 l1_s2515)))-  (let ((l1_s3102 (xor l1_s486 l1_s3101)))-  (let ((l1_s3103 (ite l1_s2547 l1_s3102 l1_s3101)))-  (let ((l1_s3104 (xor l1_s456 l1_s3103)))-  (let ((l1_s3105 (ite l1_s2579 l1_s3104 l1_s3103)))-  (let ((l1_s3106 (xor l1_s428 l1_s3105)))-  (let ((l1_s3107 (ite l1_s2611 l1_s3106 l1_s3105)))-  (let ((l1_s3108 (xor l1_s402 l1_s3107)))-  (let ((l1_s3109 (ite l1_s2643 l1_s3108 l1_s3107)))-  (let ((l1_s3110 (xor l1_s378 l1_s3109)))-  (let ((l1_s3111 (ite l1_s2675 l1_s3110 l1_s3109)))-  (let ((l1_s3112 (xor l1_s356 l1_s3111)))-  (let ((l1_s3113 (ite l1_s2707 l1_s3112 l1_s3111)))-  (let ((l1_s3114 (xor l1_s336 l1_s3113)))-  (let ((l1_s3115 (ite l1_s2739 l1_s3114 l1_s3113)))-  (let ((l1_s3116 (xor l1_s318 l1_s3115)))-  (let ((l1_s3117 (ite l1_s2771 l1_s3116 l1_s3115)))-  (let ((l1_s3118 (xor l1_s302 l1_s3117)))-  (let ((l1_s3119 (ite l1_s2803 l1_s3118 l1_s3117)))-  (let ((l1_s3120 (xor l1_s288 l1_s3119)))-  (let ((l1_s3121 (ite l1_s2835 l1_s3120 l1_s3119)))-  (let ((l1_s3122 (xor l1_s3100 l1_s3121)))-  (let ((l1_s3123 (and l1_s4 l1_s1252)))-  (let ((l1_s3124 (xor l1_s486 l1_s3123)))-  (let ((l1_s3125 (ite l1_s1284 l1_s3124 l1_s3123)))-  (let ((l1_s3126 (xor l1_s456 l1_s3125)))-  (let ((l1_s3127 (ite l1_s1316 l1_s3126 l1_s3125)))-  (let ((l1_s3128 (xor l1_s428 l1_s3127)))-  (let ((l1_s3129 (ite l1_s1348 l1_s3128 l1_s3127)))-  (let ((l1_s3130 (xor l1_s402 l1_s3129)))-  (let ((l1_s3131 (ite l1_s1380 l1_s3130 l1_s3129)))-  (let ((l1_s3132 (xor l1_s378 l1_s3131)))-  (let ((l1_s3133 (ite l1_s1412 l1_s3132 l1_s3131)))-  (let ((l1_s3134 (xor l1_s356 l1_s3133)))-  (let ((l1_s3135 (ite l1_s1444 l1_s3134 l1_s3133)))-  (let ((l1_s3136 (xor l1_s336 l1_s3135)))-  (let ((l1_s3137 (ite l1_s1476 l1_s3136 l1_s3135)))-  (let ((l1_s3138 (xor l1_s318 l1_s3137)))-  (let ((l1_s3139 (ite l1_s1508 l1_s3138 l1_s3137)))-  (let ((l1_s3140 (xor l1_s302 l1_s3139)))-  (let ((l1_s3141 (ite l1_s1540 l1_s3140 l1_s3139)))-  (let ((l1_s3142 (and l1_s4 l1_s2547)))-  (let ((l1_s3143 (xor l1_s486 l1_s3142)))-  (let ((l1_s3144 (ite l1_s2579 l1_s3143 l1_s3142)))-  (let ((l1_s3145 (xor l1_s456 l1_s3144)))-  (let ((l1_s3146 (ite l1_s2611 l1_s3145 l1_s3144)))-  (let ((l1_s3147 (xor l1_s428 l1_s3146)))-  (let ((l1_s3148 (ite l1_s2643 l1_s3147 l1_s3146)))-  (let ((l1_s3149 (xor l1_s402 l1_s3148)))-  (let ((l1_s3150 (ite l1_s2675 l1_s3149 l1_s3148)))-  (let ((l1_s3151 (xor l1_s378 l1_s3150)))-  (let ((l1_s3152 (ite l1_s2707 l1_s3151 l1_s3150)))-  (let ((l1_s3153 (xor l1_s356 l1_s3152)))-  (let ((l1_s3154 (ite l1_s2739 l1_s3153 l1_s3152)))-  (let ((l1_s3155 (xor l1_s336 l1_s3154)))-  (let ((l1_s3156 (ite l1_s2771 l1_s3155 l1_s3154)))-  (let ((l1_s3157 (xor l1_s318 l1_s3156)))-  (let ((l1_s3158 (ite l1_s2803 l1_s3157 l1_s3156)))-  (let ((l1_s3159 (xor l1_s302 l1_s3158)))-  (let ((l1_s3160 (ite l1_s2835 l1_s3159 l1_s3158)))-  (let ((l1_s3161 (xor l1_s3141 l1_s3160)))-  (let ((l1_s3162 (and l1_s4 l1_s1284)))-  (let ((l1_s3163 (xor l1_s486 l1_s3162)))-  (let ((l1_s3164 (ite l1_s1316 l1_s3163 l1_s3162)))-  (let ((l1_s3165 (xor l1_s456 l1_s3164)))-  (let ((l1_s3166 (ite l1_s1348 l1_s3165 l1_s3164)))-  (let ((l1_s3167 (xor l1_s428 l1_s3166)))-  (let ((l1_s3168 (ite l1_s1380 l1_s3167 l1_s3166)))-  (let ((l1_s3169 (xor l1_s402 l1_s3168)))-  (let ((l1_s3170 (ite l1_s1412 l1_s3169 l1_s3168)))-  (let ((l1_s3171 (xor l1_s378 l1_s3170)))-  (let ((l1_s3172 (ite l1_s1444 l1_s3171 l1_s3170)))-  (let ((l1_s3173 (xor l1_s356 l1_s3172)))-  (let ((l1_s3174 (ite l1_s1476 l1_s3173 l1_s3172)))-  (let ((l1_s3175 (xor l1_s336 l1_s3174)))-  (let ((l1_s3176 (ite l1_s1508 l1_s3175 l1_s3174)))-  (let ((l1_s3177 (xor l1_s318 l1_s3176)))-  (let ((l1_s3178 (ite l1_s1540 l1_s3177 l1_s3176)))-  (let ((l1_s3179 (and l1_s4 l1_s2579)))-  (let ((l1_s3180 (xor l1_s486 l1_s3179)))-  (let ((l1_s3181 (ite l1_s2611 l1_s3180 l1_s3179)))-  (let ((l1_s3182 (xor l1_s456 l1_s3181)))-  (let ((l1_s3183 (ite l1_s2643 l1_s3182 l1_s3181)))-  (let ((l1_s3184 (xor l1_s428 l1_s3183)))-  (let ((l1_s3185 (ite l1_s2675 l1_s3184 l1_s3183)))-  (let ((l1_s3186 (xor l1_s402 l1_s3185)))-  (let ((l1_s3187 (ite l1_s2707 l1_s3186 l1_s3185)))-  (let ((l1_s3188 (xor l1_s378 l1_s3187)))-  (let ((l1_s3189 (ite l1_s2739 l1_s3188 l1_s3187)))-  (let ((l1_s3190 (xor l1_s356 l1_s3189)))-  (let ((l1_s3191 (ite l1_s2771 l1_s3190 l1_s3189)))-  (let ((l1_s3192 (xor l1_s336 l1_s3191)))-  (let ((l1_s3193 (ite l1_s2803 l1_s3192 l1_s3191)))-  (let ((l1_s3194 (xor l1_s318 l1_s3193)))-  (let ((l1_s3195 (ite l1_s2835 l1_s3194 l1_s3193)))-  (let ((l1_s3196 (xor l1_s3178 l1_s3195)))-  (let ((l1_s3197 (and l1_s4 l1_s1316)))-  (let ((l1_s3198 (xor l1_s486 l1_s3197)))-  (let ((l1_s3199 (ite l1_s1348 l1_s3198 l1_s3197)))-  (let ((l1_s3200 (xor l1_s456 l1_s3199)))-  (let ((l1_s3201 (ite l1_s1380 l1_s3200 l1_s3199)))-  (let ((l1_s3202 (xor l1_s428 l1_s3201)))-  (let ((l1_s3203 (ite l1_s1412 l1_s3202 l1_s3201)))-  (let ((l1_s3204 (xor l1_s402 l1_s3203)))-  (let ((l1_s3205 (ite l1_s1444 l1_s3204 l1_s3203)))-  (let ((l1_s3206 (xor l1_s378 l1_s3205)))-  (let ((l1_s3207 (ite l1_s1476 l1_s3206 l1_s3205)))-  (let ((l1_s3208 (xor l1_s356 l1_s3207)))-  (let ((l1_s3209 (ite l1_s1508 l1_s3208 l1_s3207)))-  (let ((l1_s3210 (xor l1_s336 l1_s3209)))-  (let ((l1_s3211 (ite l1_s1540 l1_s3210 l1_s3209)))-  (let ((l1_s3212 (and l1_s4 l1_s2611)))-  (let ((l1_s3213 (xor l1_s486 l1_s3212)))-  (let ((l1_s3214 (ite l1_s2643 l1_s3213 l1_s3212)))-  (let ((l1_s3215 (xor l1_s456 l1_s3214)))-  (let ((l1_s3216 (ite l1_s2675 l1_s3215 l1_s3214)))-  (let ((l1_s3217 (xor l1_s428 l1_s3216)))-  (let ((l1_s3218 (ite l1_s2707 l1_s3217 l1_s3216)))-  (let ((l1_s3219 (xor l1_s402 l1_s3218)))-  (let ((l1_s3220 (ite l1_s2739 l1_s3219 l1_s3218)))-  (let ((l1_s3221 (xor l1_s378 l1_s3220)))-  (let ((l1_s3222 (ite l1_s2771 l1_s3221 l1_s3220)))-  (let ((l1_s3223 (xor l1_s356 l1_s3222)))-  (let ((l1_s3224 (ite l1_s2803 l1_s3223 l1_s3222)))-  (let ((l1_s3225 (xor l1_s336 l1_s3224)))-  (let ((l1_s3226 (ite l1_s2835 l1_s3225 l1_s3224)))-  (let ((l1_s3227 (xor l1_s3211 l1_s3226)))-  (let ((l1_s3228 (and l1_s4 l1_s1348)))-  (let ((l1_s3229 (xor l1_s486 l1_s3228)))-  (let ((l1_s3230 (ite l1_s1380 l1_s3229 l1_s3228)))-  (let ((l1_s3231 (xor l1_s456 l1_s3230)))-  (let ((l1_s3232 (ite l1_s1412 l1_s3231 l1_s3230)))-  (let ((l1_s3233 (xor l1_s428 l1_s3232)))-  (let ((l1_s3234 (ite l1_s1444 l1_s3233 l1_s3232)))-  (let ((l1_s3235 (xor l1_s402 l1_s3234)))-  (let ((l1_s3236 (ite l1_s1476 l1_s3235 l1_s3234)))-  (let ((l1_s3237 (xor l1_s378 l1_s3236)))-  (let ((l1_s3238 (ite l1_s1508 l1_s3237 l1_s3236)))-  (let ((l1_s3239 (xor l1_s356 l1_s3238)))-  (let ((l1_s3240 (ite l1_s1540 l1_s3239 l1_s3238)))-  (let ((l1_s3241 (and l1_s4 l1_s2643)))-  (let ((l1_s3242 (xor l1_s486 l1_s3241)))-  (let ((l1_s3243 (ite l1_s2675 l1_s3242 l1_s3241)))-  (let ((l1_s3244 (xor l1_s456 l1_s3243)))-  (let ((l1_s3245 (ite l1_s2707 l1_s3244 l1_s3243)))-  (let ((l1_s3246 (xor l1_s428 l1_s3245)))-  (let ((l1_s3247 (ite l1_s2739 l1_s3246 l1_s3245)))-  (let ((l1_s3248 (xor l1_s402 l1_s3247)))-  (let ((l1_s3249 (ite l1_s2771 l1_s3248 l1_s3247)))-  (let ((l1_s3250 (xor l1_s378 l1_s3249)))-  (let ((l1_s3251 (ite l1_s2803 l1_s3250 l1_s3249)))-  (let ((l1_s3252 (xor l1_s356 l1_s3251)))-  (let ((l1_s3253 (ite l1_s2835 l1_s3252 l1_s3251)))-  (let ((l1_s3254 (xor l1_s3240 l1_s3253)))-  (let ((l1_s3255 (and l1_s4 l1_s1380)))-  (let ((l1_s3256 (xor l1_s486 l1_s3255)))-  (let ((l1_s3257 (ite l1_s1412 l1_s3256 l1_s3255)))-  (let ((l1_s3258 (xor l1_s456 l1_s3257)))-  (let ((l1_s3259 (ite l1_s1444 l1_s3258 l1_s3257)))-  (let ((l1_s3260 (xor l1_s428 l1_s3259)))-  (let ((l1_s3261 (ite l1_s1476 l1_s3260 l1_s3259)))-  (let ((l1_s3262 (xor l1_s402 l1_s3261)))-  (let ((l1_s3263 (ite l1_s1508 l1_s3262 l1_s3261)))-  (let ((l1_s3264 (xor l1_s378 l1_s3263)))-  (let ((l1_s3265 (ite l1_s1540 l1_s3264 l1_s3263)))-  (let ((l1_s3266 (and l1_s4 l1_s2675)))-  (let ((l1_s3267 (xor l1_s486 l1_s3266)))-  (let ((l1_s3268 (ite l1_s2707 l1_s3267 l1_s3266)))-  (let ((l1_s3269 (xor l1_s456 l1_s3268)))-  (let ((l1_s3270 (ite l1_s2739 l1_s3269 l1_s3268)))-  (let ((l1_s3271 (xor l1_s428 l1_s3270)))-  (let ((l1_s3272 (ite l1_s2771 l1_s3271 l1_s3270)))-  (let ((l1_s3273 (xor l1_s402 l1_s3272)))-  (let ((l1_s3274 (ite l1_s2803 l1_s3273 l1_s3272)))-  (let ((l1_s3275 (xor l1_s378 l1_s3274)))-  (let ((l1_s3276 (ite l1_s2835 l1_s3275 l1_s3274)))-  (let ((l1_s3277 (xor l1_s3265 l1_s3276)))-  (let ((l1_s3278 (and l1_s4 l1_s1412)))-  (let ((l1_s3279 (xor l1_s486 l1_s3278)))-  (let ((l1_s3280 (ite l1_s1444 l1_s3279 l1_s3278)))-  (let ((l1_s3281 (xor l1_s456 l1_s3280)))-  (let ((l1_s3282 (ite l1_s1476 l1_s3281 l1_s3280)))-  (let ((l1_s3283 (xor l1_s428 l1_s3282)))-  (let ((l1_s3284 (ite l1_s1508 l1_s3283 l1_s3282)))-  (let ((l1_s3285 (xor l1_s402 l1_s3284)))-  (let ((l1_s3286 (ite l1_s1540 l1_s3285 l1_s3284)))-  (let ((l1_s3287 (and l1_s4 l1_s2707)))-  (let ((l1_s3288 (xor l1_s486 l1_s3287)))-  (let ((l1_s3289 (ite l1_s2739 l1_s3288 l1_s3287)))-  (let ((l1_s3290 (xor l1_s456 l1_s3289)))-  (let ((l1_s3291 (ite l1_s2771 l1_s3290 l1_s3289)))-  (let ((l1_s3292 (xor l1_s428 l1_s3291)))-  (let ((l1_s3293 (ite l1_s2803 l1_s3292 l1_s3291)))-  (let ((l1_s3294 (xor l1_s402 l1_s3293)))-  (let ((l1_s3295 (ite l1_s2835 l1_s3294 l1_s3293)))-  (let ((l1_s3296 (xor l1_s3286 l1_s3295)))-  (let ((l1_s3297 (and l1_s4 l1_s1444)))-  (let ((l1_s3298 (xor l1_s486 l1_s3297)))-  (let ((l1_s3299 (ite l1_s1476 l1_s3298 l1_s3297)))-  (let ((l1_s3300 (xor l1_s456 l1_s3299)))-  (let ((l1_s3301 (ite l1_s1508 l1_s3300 l1_s3299)))-  (let ((l1_s3302 (xor l1_s428 l1_s3301)))-  (let ((l1_s3303 (ite l1_s1540 l1_s3302 l1_s3301)))-  (let ((l1_s3304 (and l1_s4 l1_s2739)))-  (let ((l1_s3305 (xor l1_s486 l1_s3304)))-  (let ((l1_s3306 (ite l1_s2771 l1_s3305 l1_s3304)))-  (let ((l1_s3307 (xor l1_s456 l1_s3306)))-  (let ((l1_s3308 (ite l1_s2803 l1_s3307 l1_s3306)))-  (let ((l1_s3309 (xor l1_s428 l1_s3308)))-  (let ((l1_s3310 (ite l1_s2835 l1_s3309 l1_s3308)))-  (let ((l1_s3311 (xor l1_s3303 l1_s3310)))-  (let ((l1_s3312 (and l1_s4 l1_s1476)))-  (let ((l1_s3313 (xor l1_s486 l1_s3312)))-  (let ((l1_s3314 (ite l1_s1508 l1_s3313 l1_s3312)))-  (let ((l1_s3315 (xor l1_s456 l1_s3314)))-  (let ((l1_s3316 (ite l1_s1540 l1_s3315 l1_s3314)))-  (let ((l1_s3317 (and l1_s4 l1_s2771)))-  (let ((l1_s3318 (xor l1_s486 l1_s3317)))-  (let ((l1_s3319 (ite l1_s2803 l1_s3318 l1_s3317)))-  (let ((l1_s3320 (xor l1_s456 l1_s3319)))-  (let ((l1_s3321 (ite l1_s2835 l1_s3320 l1_s3319)))-  (let ((l1_s3322 (xor l1_s3316 l1_s3321)))-  (let ((l1_s3323 (and l1_s4 l1_s1508)))-  (let ((l1_s3324 (xor l1_s486 l1_s3323)))-  (let ((l1_s3325 (ite l1_s1540 l1_s3324 l1_s3323)))-  (let ((l1_s3326 (and l1_s4 l1_s2803)))-  (let ((l1_s3327 (xor l1_s486 l1_s3326)))-  (let ((l1_s3328 (ite l1_s2835 l1_s3327 l1_s3326)))-  (let ((l1_s3329 (xor l1_s3325 l1_s3328)))-  (let ((l1_s3330 (and l1_s4 l1_s1540)))-  (let ((l1_s3331 (and l1_s4 l1_s2835)))-  (let ((l1_s3332 (xor l1_s3330 l1_s3331)))-  (let ((l1_s3334 (ite l1_s3332 l1_s11 l1_s3333)))-  (let ((l1_s3335 (bvadd l1_s11 l1_s3334)))-  (let ((l1_s3336 (ite l1_s3329 l1_s3335 l1_s3334)))-  (let ((l1_s3337 (bvadd l1_s11 l1_s3336)))-  (let ((l1_s3338 (ite l1_s3322 l1_s3337 l1_s3336)))-  (let ((l1_s3339 (bvadd l1_s11 l1_s3338)))-  (let ((l1_s3340 (ite l1_s3311 l1_s3339 l1_s3338)))-  (let ((l1_s3341 (bvadd l1_s11 l1_s3340)))-  (let ((l1_s3342 (ite l1_s3296 l1_s3341 l1_s3340)))-  (let ((l1_s3343 (bvadd l1_s11 l1_s3342)))-  (let ((l1_s3344 (ite l1_s3277 l1_s3343 l1_s3342)))-  (let ((l1_s3345 (bvadd l1_s11 l1_s3344)))-  (let ((l1_s3346 (ite l1_s3254 l1_s3345 l1_s3344)))-  (let ((l1_s3347 (bvadd l1_s11 l1_s3346)))-  (let ((l1_s3348 (ite l1_s3227 l1_s3347 l1_s3346)))-  (let ((l1_s3349 (bvadd l1_s11 l1_s3348)))-  (let ((l1_s3350 (ite l1_s3196 l1_s3349 l1_s3348)))-  (let ((l1_s3351 (bvadd l1_s11 l1_s3350)))-  (let ((l1_s3352 (ite l1_s3161 l1_s3351 l1_s3350)))-  (let ((l1_s3353 (bvadd l1_s11 l1_s3352)))-  (let ((l1_s3354 (ite l1_s3122 l1_s3353 l1_s3352)))-  (let ((l1_s3355 (bvadd l1_s11 l1_s3354)))-  (let ((l1_s3356 (ite l1_s3079 l1_s3355 l1_s3354)))-  (let ((l1_s3357 (bvadd l1_s11 l1_s3356)))-  (let ((l1_s3358 (ite l1_s3032 l1_s3357 l1_s3356)))-  (let ((l1_s3359 (bvadd l1_s11 l1_s3358)))-  (let ((l1_s3360 (ite l1_s2981 l1_s3359 l1_s3358)))-  (let ((l1_s3361 (bvadd l1_s11 l1_s3360)))-  (let ((l1_s3362 (ite l1_s2926 l1_s3361 l1_s3360)))-  (let ((l1_s3363 (bvadd l1_s11 l1_s3362)))-  (let ((l1_s3364 (ite l1_s2867 l1_s3363 l1_s3362)))-  (let ((l1_s3365 (bvadd l1_s11 l1_s3364)))-  (let ((l1_s3366 (ite l1_s246 l1_s3365 l1_s3364)))-  (let ((l1_s3367 (bvadd l1_s11 l1_s3366)))-  (let ((l1_s3368 (ite l1_s241 l1_s3367 l1_s3366)))-  (let ((l1_s3369 (bvadd l1_s11 l1_s3368)))-  (let ((l1_s3370 (ite l1_s236 l1_s3369 l1_s3368)))-  (let ((l1_s3371 (bvadd l1_s11 l1_s3370)))-  (let ((l1_s3372 (ite l1_s231 l1_s3371 l1_s3370)))-  (let ((l1_s3373 (bvadd l1_s11 l1_s3372)))-  (let ((l1_s3374 (ite l1_s226 l1_s3373 l1_s3372)))-  (let ((l1_s3375 (bvadd l1_s11 l1_s3374)))-  (let ((l1_s3376 (ite l1_s221 l1_s3375 l1_s3374)))-  (let ((l1_s3377 (bvadd l1_s11 l1_s3376)))-  (let ((l1_s3378 (ite l1_s216 l1_s3377 l1_s3376)))-  (let ((l1_s3379 (bvadd l1_s11 l1_s3378)))-  (let ((l1_s3380 (ite l1_s211 l1_s3379 l1_s3378)))-  (let ((l1_s3381 (bvadd l1_s11 l1_s3380)))-  (let ((l1_s3382 (ite l1_s206 l1_s3381 l1_s3380)))-  (let ((l1_s3383 (bvadd l1_s11 l1_s3382)))-  (let ((l1_s3384 (ite l1_s201 l1_s3383 l1_s3382)))-  (let ((l1_s3385 (bvadd l1_s11 l1_s3384)))-  (let ((l1_s3386 (ite l1_s196 l1_s3385 l1_s3384)))-  (let ((l1_s3387 (bvadd l1_s11 l1_s3386)))-  (let ((l1_s3388 (ite l1_s191 l1_s3387 l1_s3386)))-  (let ((l1_s3389 (bvadd l1_s11 l1_s3388)))-  (let ((l1_s3390 (ite l1_s186 l1_s3389 l1_s3388)))-  (let ((l1_s3391 (bvadd l1_s11 l1_s3390)))-  (let ((l1_s3392 (ite l1_s181 l1_s3391 l1_s3390)))-  (let ((l1_s3393 (bvadd l1_s11 l1_s3392)))-  (let ((l1_s3394 (ite l1_s176 l1_s3393 l1_s3392)))-  (let ((l1_s3395 (bvadd l1_s11 l1_s3394)))-  (let ((l1_s3396 (ite l1_s171 l1_s3395 l1_s3394)))-  (let ((l1_s3397 (bvadd l1_s11 l1_s3396)))-  (let ((l1_s3398 (ite l1_s166 l1_s3397 l1_s3396)))-  (let ((l1_s3399 (bvadd l1_s11 l1_s3398)))-  (let ((l1_s3400 (ite l1_s161 l1_s3399 l1_s3398)))-  (let ((l1_s3401 (bvadd l1_s11 l1_s3400)))-  (let ((l1_s3402 (ite l1_s156 l1_s3401 l1_s3400)))-  (let ((l1_s3403 (bvadd l1_s11 l1_s3402)))-  (let ((l1_s3404 (ite l1_s151 l1_s3403 l1_s3402)))-  (let ((l1_s3405 (bvadd l1_s11 l1_s3404)))-  (let ((l1_s3406 (ite l1_s146 l1_s3405 l1_s3404)))-  (let ((l1_s3407 (bvadd l1_s11 l1_s3406)))-  (let ((l1_s3408 (ite l1_s141 l1_s3407 l1_s3406)))-  (let ((l1_s3409 (bvadd l1_s11 l1_s3408)))-  (let ((l1_s3410 (ite l1_s136 l1_s3409 l1_s3408)))-  (let ((l1_s3411 (bvadd l1_s11 l1_s3410)))-  (let ((l1_s3412 (ite l1_s131 l1_s3411 l1_s3410)))-  (let ((l1_s3413 (bvadd l1_s11 l1_s3412)))-  (let ((l1_s3414 (ite l1_s126 l1_s3413 l1_s3412)))-  (let ((l1_s3415 (bvadd l1_s11 l1_s3414)))-  (let ((l1_s3416 (ite l1_s121 l1_s3415 l1_s3414)))-  (let ((l1_s3417 (bvadd l1_s11 l1_s3416)))-  (let ((l1_s3418 (ite l1_s116 l1_s3417 l1_s3416)))-  (let ((l1_s3419 (bvadd l1_s11 l1_s3418)))-  (let ((l1_s3420 (ite l1_s111 l1_s3419 l1_s3418)))-  (let ((l1_s3421 (bvadd l1_s11 l1_s3420)))-  (let ((l1_s3422 (ite l1_s106 l1_s3421 l1_s3420)))-  (let ((l1_s3423 (bvadd l1_s11 l1_s3422)))-  (let ((l1_s3424 (ite l1_s101 l1_s3423 l1_s3422)))-  (let ((l1_s3425 (bvadd l1_s11 l1_s3424)))-  (let ((l1_s3426 (ite l1_s96 l1_s3425 l1_s3424)))-  (let ((l1_s3427 (bvadd l1_s11 l1_s3426)))-  (let ((l1_s3428 (ite l1_s91 l1_s3427 l1_s3426)))-  (let ((l1_s3429 (bvadd l1_s11 l1_s3428)))-  (let ((l1_s3430 (ite l1_s86 l1_s3429 l1_s3428)))-  (let ((l1_s3431 (bvadd l1_s11 l1_s3430)))-  (let ((l1_s3432 (ite l1_s81 l1_s3431 l1_s3430)))-  (let ((l1_s3433 (bvadd l1_s11 l1_s3432)))-  (let ((l1_s3434 (ite l1_s76 l1_s3433 l1_s3432)))-  (let ((l1_s3435 (bvadd l1_s11 l1_s3434)))-  (let ((l1_s3436 (ite l1_s71 l1_s3435 l1_s3434)))-  (let ((l1_s3437 (bvadd l1_s11 l1_s3436)))-  (let ((l1_s3438 (ite l1_s66 l1_s3437 l1_s3436)))-  (let ((l1_s3439 (bvadd l1_s11 l1_s3438)))-  (let ((l1_s3440 (ite l1_s61 l1_s3439 l1_s3438)))-  (let ((l1_s3441 (bvadd l1_s11 l1_s3440)))-  (let ((l1_s3442 (ite l1_s56 l1_s3441 l1_s3440)))-  (let ((l1_s3443 (bvadd l1_s11 l1_s3442)))-  (let ((l1_s3444 (ite l1_s51 l1_s3443 l1_s3442)))-  (let ((l1_s3445 (bvadd l1_s11 l1_s3444)))-  (let ((l1_s3446 (ite l1_s46 l1_s3445 l1_s3444)))-  (let ((l1_s3447 (bvadd l1_s11 l1_s3446)))-  (let ((l1_s3448 (ite l1_s41 l1_s3447 l1_s3446)))-  (let ((l1_s3449 (bvadd l1_s11 l1_s3448)))-  (let ((l1_s3450 (ite l1_s36 l1_s3449 l1_s3448)))-  (let ((l1_s3451 (bvadd l1_s11 l1_s3450)))-  (let ((l1_s3452 (ite l1_s31 l1_s3451 l1_s3450)))-  (let ((l1_s3453 (bvadd l1_s11 l1_s3452)))-  (let ((l1_s3454 (ite l1_s26 l1_s3453 l1_s3452)))-  (let ((l1_s3455 (bvadd l1_s11 l1_s3454)))-  (let ((l1_s3456 (ite l1_s21 l1_s3455 l1_s3454)))-  (let ((l1_s3457 (bvadd l1_s11 l1_s3456)))-  (let ((l1_s3458 (ite l1_s16 l1_s3457 l1_s3456)))-  (let ((l1_s3459 (bvadd l1_s11 l1_s3458)))-  (let ((l1_s3460 (ite l1_s10 l1_s3459 l1_s3458)))-  (let ((l1_s3462 (bvuge l1_s3460 l1_s3461)))-  (let ((l1_s3463 (=> l1_s5 l1_s3462)))-  (let ((l1_s3464 (and l1_s4 l1_s3463)))-  l1_s3464))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))-CONSTRAINTS-ASSERTIONS-OUTPUTS-  s1
SBVTestSuite/GoldFiles/lambda40.gold view
@@ -1,3 +1,3 @@-; -- user given definition: lambda40+; lambda40 :: SInteger (define-fun lambda40 () Int   0)
SBVTestSuite/GoldFiles/lambda41.gold view
@@ -1,4 +1,4 @@-; -- user given definition: lambda41+; lambda41 :: SInteger -> SInteger (define-fun lambda41 ((l1_s0 Int)) Int   (let ((l1_s1 1))   (let ((l1_s2 (+ l1_s0 l1_s1)))
SBVTestSuite/GoldFiles/lambda42.gold view
@@ -1,3 +1,3 @@-; -- user given definition: lambda42+; lambda42 :: SInteger -> SInteger -> SInteger (define-fun lambda42 ((l1_s0 Int) (l1_s1 Int)) Int   (+ l1_s0 l1_s1))
SBVTestSuite/GoldFiles/lambda43.gold view
@@ -1,3 +1,3 @@-; -- user given definition: lambda43+; lambda43 :: SWord32 (define-fun lambda43 () (_ BitVec 32)   #x00000000)
SBVTestSuite/GoldFiles/lambda44.gold view
@@ -1,4 +1,4 @@-; -- user given definition: lambda44+; lambda44 :: SWord32 -> SWord32 (define-fun lambda44 ((l1_s0 (_ BitVec 32))) (_ BitVec 32)   (let ((l1_s1 #x00000001))   (let ((l1_s2 (bvadd l1_s0 l1_s1)))
SBVTestSuite/GoldFiles/lambda45.gold view
@@ -1,3 +1,3 @@-; -- user given definition: lambda45+; lambda45 :: SWord32 -> SWord32 -> SWord32 (define-fun lambda45 ((l1_s0 (_ BitVec 32)) (l1_s1 (_ BitVec 32))) (_ BitVec 32)   (bvadd l1_s0 l1_s1))
SBVTestSuite/GoldFiles/lambda46.gold view
@@ -18,7 +18,7 @@ [GOOD] ; --- arrays --- [GOOD] ; --- uninterpreted constants --- [GOOD] ; --- user defined functions ----[GOOD] ; -- user given definition: add1+[GOOD] ; add1 :: SInteger -> SInteger [GOOD] (define-fun add1 ((l1_s0 Int)) Int          (let ((l1_s1 1))          (let ((l1_s2 (+ l1_s0 l1_s1)))
SBVTestSuite/GoldFiles/lambda47.gold view
@@ -19,7 +19,7 @@ [GOOD] ; --- arrays --- [GOOD] ; --- uninterpreted constants --- [GOOD] ; --- user defined functions ----[GOOD] ; -- user given definition: sumToN [Recursive]+[GOOD] ; sumToN :: SInteger -> SInteger [Recursive] [GOOD] (define-fun-rec sumToN ((l1_s0 Int)) Int          (let ((l1_s1 0))          (let ((l1_s3 1))
SBVTestSuite/GoldFiles/lambda48.gold view
@@ -22,7 +22,7 @@ [GOOD] ; --- arrays --- [GOOD] ; --- uninterpreted constants --- [GOOD] ; --- user defined functions ----[GOOD] ; -- user given definition: list_length [Recursive]+[GOOD] ; list_length :: [SInteger] -> SInteger [Recursive] [GOOD] (define-fun-rec list_length ((l1_s0 (Seq Int))) Int          (let ((l1_s2 0))          (let ((l1_s4 1))
SBVTestSuite/GoldFiles/lambda49.gold view
@@ -25,7 +25,7 @@ [GOOD] ; --- arrays --- [GOOD] ; --- uninterpreted constants --- [GOOD] ; --- user defined functions ----[GOOD] ; -- user given definition: isEvenOdd [Recursive]+[GOOD] ; isEvenOdd :: SInteger -> (SBool, SBool) [Recursive] [GOOD] (define-fun-rec isEvenOdd ((l1_s0 Int)) (SBVTuple2 Bool Bool)          (let ((l1_s1 0))          (let ((l1_s6 (mkSBVTuple2 true false)))
SBVTestSuite/GoldFiles/lambda50.gold view
@@ -25,7 +25,7 @@ [GOOD] ; --- arrays --- [GOOD] ; --- uninterpreted constants --- [GOOD] ; --- user defined functions ----[GOOD] ; -- user given definition: isEvenOdd [Recursive]+[GOOD] ; isEvenOdd :: SInteger -> (SBool, SBool) [Recursive] [GOOD] (define-fun-rec isEvenOdd ((l1_s0 Int)) (SBVTuple2 Bool Bool)          (let ((l1_s1 0))          (let ((l1_s6 (mkSBVTuple2 true false)))
SBVTestSuite/GoldFiles/lambda51.gold view
@@ -25,7 +25,7 @@ [GOOD] ; --- arrays --- [GOOD] ; --- uninterpreted constants --- [GOOD] ; --- user defined functions ----[GOOD] ; -- user given definition: isEvenOdd [Recursive]+[GOOD] ; isEvenOdd :: SInteger -> (SBool, SBool) [Recursive] [GOOD] (define-fun-rec isEvenOdd ((l1_s0 Int)) (SBVTuple2 Bool Bool)          (let ((l1_s1 0))          (let ((l1_s6 (mkSBVTuple2 true false)))
SBVTestSuite/GoldFiles/lambda52.gold view
@@ -25,7 +25,7 @@ [GOOD] ; --- arrays --- [GOOD] ; --- uninterpreted constants --- [GOOD] ; --- user defined functions ----[GOOD] ; -- user given definition: isEvenOdd [Recursive]+[GOOD] ; isEvenOdd :: SInteger -> (SBool, SBool) [Recursive] [GOOD] (define-fun-rec isEvenOdd ((l1_s0 Int)) (SBVTuple2 Bool Bool)          (let ((l1_s1 0))          (let ((l1_s6 (mkSBVTuple2 true false)))
SBVTestSuite/GoldFiles/lambda53.gold view
@@ -17,7 +17,7 @@ [GOOD] ; --- arrays --- [GOOD] ; --- uninterpreted constants --- [GOOD] ; --- user defined functions ----[GOOD] ; -- user given definition: foo+[GOOD] ; foo :: SInteger -> SInteger [GOOD] (define-fun foo ((l1_s0 Int)) Int          (+ s0 l1_s0)) [GOOD] ; --- assignments ---
SBVTestSuite/GoldFiles/lambda54.gold view
@@ -17,12 +17,12 @@ [GOOD] ; --- arrays --- [GOOD] ; --- uninterpreted constants --- [GOOD] ; --- user defined functions ----[GOOD] ; -- user given definition: bar+[GOOD] ; bar :: SInteger -> SInteger [GOOD] (define-fun bar ((l1_s0 Int)) Int          (let ((l1_s1 1))          (let ((l1_s2 (+ l1_s0 l1_s1)))          l1_s2)))-[GOOD] ; -- user given definition: foo [Refers to: bar]+[GOOD] ; foo :: SInteger -> SInteger [Refers to: bar] [GOOD] (define-fun foo ((l1_s0 Int)) Int          (let ((l1_s2 1))          (let ((l1_s1 (bar l1_s0)))
SBVTestSuite/GoldFiles/lambda55.gold view
@@ -17,12 +17,12 @@ [GOOD] ; --- arrays --- [GOOD] ; --- uninterpreted constants --- [GOOD] ; --- user defined functions ----[GOOD] ; -- user given definition: bar+[GOOD] ; bar :: SInteger -> SInteger [GOOD] (define-fun bar ((l2_s0 Int)) Int          (let ((l2_s1 1))          (let ((l2_s2 (+ l2_s0 l2_s1)))          l2_s2)))-[GOOD] ; -- user given definition: foo [Refers to: bar]+[GOOD] ; foo :: SInteger -> SInteger [Refers to: bar] [GOOD] (define-fun foo ((l1_s0 Int)) Int          (let ((l1_s2 1))          (let ((l1_s1 (bar l1_s0)))
SBVTestSuite/GoldFiles/lambda56.gold view
@@ -17,16 +17,16 @@ [GOOD] ; --- arrays --- [GOOD] ; --- uninterpreted constants --- [GOOD] ; --- user defined functions ----[GOOD] ; -- user given mutually-recursive definitions: bar, foo+[GOOD] ; bar :: SInteger -> SInteger, foo :: SInteger -> SInteger [GOOD] (define-funs-rec          ((bar ((l2_s0 Int)) Int)           (foo ((l1_s0 Int)) Int))-         (; Definition of: bar. [Refers to: foo]+         (; Definition of: bar :: SInteger -> SInteger. [Refers to: foo]           (let ((l2_s2 1))           (let ((l2_s1 (foo l2_s0)))           (let ((l2_s3 (+ l2_s1 l2_s2)))           l2_s3)))-          ; Definition of: foo. [Refers to: bar]+          ; Definition of: foo :: SInteger -> SInteger. [Refers to: bar]           (let ((l1_s2 1))           (let ((l1_s1 (bar l1_s0)))           (let ((l1_s3 (+ l1_s1 l1_s2)))
SBVTestSuite/GoldFiles/lambda57.gold view
@@ -17,13 +17,13 @@ [GOOD] ; --- arrays --- [GOOD] ; --- uninterpreted constants --- [GOOD] ; --- user defined functions ----[GOOD] ; -- user given mutually-recursive definitions: f1, f2, f3, f4+[GOOD] ; f1 :: SWord8 -> SWord8, f2 :: SWord8 -> SWord8, f3 :: SWord8 -> SWord8, f4 :: SWord8 -> SWord8 [GOOD] (define-funs-rec          ((f1 ((l1_s0 (_ BitVec 8))) (_ BitVec 8))           (f2 ((l2_s0 (_ BitVec 8))) (_ BitVec 8))           (f3 ((l3_s0 (_ BitVec 8))) (_ BitVec 8))           (f4 ((l4_s0 (_ BitVec 8))) (_ BitVec 8)))-         (; Definition of: f1. [Refers to: f1, f2]+         (; Definition of: f1 :: SWord8 -> SWord8. [Refers to: f1, f2]           (let ((l1_s1 #x00))           (let ((l1_s3 #x01))           (let ((l1_s6 #x02))@@ -36,7 +36,7 @@           (let ((l1_s10 (bvadd l1_s3 l1_s9)))           (let ((l1_s11 (ite l1_s2 l1_s1 l1_s10)))           l1_s11)))))))))))-          ; Definition of: f2. [Refers to: f2, f3]+          ; Definition of: f2 :: SWord8 -> SWord8. [Refers to: f2, f3]           (let ((l2_s1 #x00))           (let ((l2_s3 #x01))           (let ((l2_s6 #x02))@@ -49,7 +49,7 @@           (let ((l2_s10 (bvadd l2_s3 l2_s9)))           (let ((l2_s11 (ite l2_s2 l2_s1 l2_s10)))           l2_s11)))))))))))-          ; Definition of: f3. [Refers to: f3, f4]+          ; Definition of: f3 :: SWord8 -> SWord8. [Refers to: f3, f4]           (let ((l3_s1 #x00))           (let ((l3_s3 #x01))           (let ((l3_s6 #x02))@@ -62,7 +62,7 @@           (let ((l3_s10 (bvadd l3_s3 l3_s9)))           (let ((l3_s11 (ite l3_s2 l3_s1 l3_s10)))           l3_s11)))))))))))-          ; Definition of: f4. [Refers to: f4, f1]+          ; Definition of: f4 :: SWord8 -> SWord8. [Refers to: f4, f1]           (let ((l4_s1 #x00))           (let ((l4_s3 #x01))           (let ((l4_s6 #x02))
SBVTestSuite/GoldFiles/lambda61.gold view
@@ -5,7 +5,7 @@ [GOOD] (set-option :smtlib2_compliant true) [GOOD] (set-option :diagnostic-output-channel "stdout") [GOOD] (set-option :produce-models true)-[GOOD] (set-logic ALL) ; external query, using all logics.+[GOOD] (set-logic ALL) ; has quantified booleans, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums ---
SBVTestSuite/GoldFiles/lambda63.gold view
@@ -37,5 +37,5 @@  RESULT: Falsifiable. Counter-example:-  R :: Integer -> Integer -> Bool-  R _ _ = False+  R :: (Integer, Integer) -> Bool+  R (_, _) = False
SBVTestSuite/GoldFiles/lambda65.gold view
@@ -17,7 +17,7 @@ [GOOD] ; --- uninterpreted constants --- [GOOD] (declare-fun __internal_sbv_IsPartialOrder__poI_ (Int Int) Bool) [GOOD] ; --- user defined functions ----[GOOD] ; -- user given definition: leq+[GOOD] ; leq :: SInteger -> SInteger -> SBool [GOOD] (define-fun leq ((l2_s0 Int) (l2_s1 Int)) Bool          (<= l2_s0 l2_s1)) [GOOD] ; --- assignments ---
SBVTestSuite/GoldFiles/lambda68.gold view
@@ -44,4 +44,4 @@ RESULT: Satisfiable. Model:   F :: Integer -> Integer-  F x = 3 + (2 * x)+  F x = 2 * x + 3
SBVTestSuite/GoldFiles/lambda69.gold view
@@ -45,4 +45,4 @@ RESULT: Satisfiable. Model:   F :: Integer -> Integer -> Integer-  F x y = 3 + (2 * x) + (-y)+  F x y = 3 + 2 * x + (-y)
+ SBVTestSuite/GoldFiles/lambda71.gold view
@@ -0,0 +1,13 @@+; Automatically generated by SBV. Do not modify!+; bar :: SInteger -> SInteger [Recursive]+(define-fun-rec bar ((l2_s0 Int)) Int+  (let ((l2_s1 1))+  (let ((l2_s2 (- l2_s0 l2_s1)))+  (let ((l2_s3 (bar l2_s2)))+  l2_s3))))+; foo :: SInteger -> SInteger [Refers to: bar]+(define-fun foo ((l1_s0 Int)) Int+  (let ((l1_s1 1))+  (let ((l1_s2 (- l1_s0 l1_s1)))+  (let ((l1_s3 (bar l1_s2)))+  l1_s3))))
+ SBVTestSuite/GoldFiles/lambda72.gold view
@@ -0,0 +1,7 @@+; Automatically generated by SBV. Do not modify!+; bar :: SInteger -> SInteger [Recursive]+(define-fun-rec bar ((l1_s0 Int)) Int+  (let ((l1_s1 1))+  (let ((l1_s2 (- l1_s0 l1_s1)))+  (let ((l1_s3 (bar l1_s2)))+  l1_s3))))
+ SBVTestSuite/GoldFiles/lambda73.gold view
@@ -0,0 +1,6 @@+; Automatically generated by SBV. Do not modify!+; baz :: SInteger -> SInteger+(define-fun baz ((l1_s0 Int)) Int+  (let ((l1_s1 1))+  (let ((l1_s2 (+ l1_s0 l1_s1)))+  l1_s2)))
+ SBVTestSuite/GoldFiles/lambda74.gold view
@@ -0,0 +1,15 @@+; Automatically generated by SBV. Do not modify!+; e :: SInteger -> SInteger, o :: SInteger -> SInteger+(define-funs-rec+  ((e ((l1_s0 Int)) Int)+   (o ((l2_s0 Int)) Int))+  (; Definition of: e :: SInteger -> SInteger. [Refers to: o]+   (let ((l1_s1 1))+   (let ((l1_s2 (- l1_s0 l1_s1)))+   (let ((l1_s3 (o l1_s2)))+   l1_s3)))+   ; Definition of: o :: SInteger -> SInteger. [Refers to: e]+   (let ((l2_s1 1))+   (let ((l2_s2 (- l2_s0 l2_s1)))+   (let ((l2_s3 (e l2_s2)))+   l2_s3)))))
+ SBVTestSuite/GoldFiles/lambda75.gold view
@@ -0,0 +1,15 @@+; Automatically generated by SBV. Do not modify!+; e :: SInteger -> SInteger, o :: SInteger -> SInteger+(define-funs-rec+  ((e ((l2_s0 Int)) Int)+   (o ((l1_s0 Int)) Int))+  (; Definition of: e :: SInteger -> SInteger. [Refers to: o]+   (let ((l2_s1 1))+   (let ((l2_s2 (- l2_s0 l2_s1)))+   (let ((l2_s3 (o l2_s2)))+   l2_s3)))+   ; Definition of: o :: SInteger -> SInteger. [Refers to: e]+   (let ((l1_s1 1))+   (let ((l1_s2 (- l1_s0 l1_s1)))+   (let ((l1_s3 (e l1_s2)))+   l1_s3)))))
+ SBVTestSuite/GoldFiles/lambda76.gold view
@@ -0,0 +1,3 @@+; Automatically generated by SBV. Do not modify!+; Type: Int+2
+ SBVTestSuite/GoldFiles/lambda77.gold view
@@ -0,0 +1,3 @@+; Automatically generated by SBV. Do not modify!+; Type: String+(_ char #x61)
+ SBVTestSuite/GoldFiles/lambda78.gold view
@@ -0,0 +1,3 @@+; Automatically generated by SBV. Do not modify!+; Type: (Seq Int)+(seq.++ (seq.unit 1) (seq.unit 2) (seq.unit 3))
+ SBVTestSuite/GoldFiles/lambda79.gold view
@@ -0,0 +1,10 @@+; Automatically generated by SBV. Do not modify!+; foo :: SInteger -> SWord32+(define-fun foo ((l1_s0 Int)) (_ BitVec 32)+  (let ((l1_s1 #x00000001))+  (let ((l1_s2 #x00000002))+  (let ((l1_s3 #x00000003))+  (let ((l1_s4 #x00000000))+  (let ((table0 (lambda ((idx Int)) (ite (= idx 0) l1_s1 (ite (= idx 1) l1_s2 l1_s3)))))+  (let ((l1_s5 (ite (or (< l1_s0 0) (<= 3 l1_s0)) l1_s4 (table0 l1_s0))))+  l1_s5)))))))
+ SBVTestSuite/GoldFiles/lambda80.gold view
@@ -0,0 +1,13 @@+; Automatically generated by SBV. Do not modify!+; foo :: SInteger -> SInteger+(define-fun foo ((l1_s0 Int)) Int+  (let ((l1_s1 1))+  (let ((l1_s3 2))+  (let ((l1_s5 3))+  (let ((l1_s7 0))+  (let ((l1_s2 (+ l1_s0 l1_s1)))+  (let ((l1_s4 (+ l1_s0 l1_s3)))+  (let ((l1_s6 (+ l1_s0 l1_s5)))+  (let ((table0 (lambda ((idx Int)) (ite (= idx 0) l1_s2 (ite (= idx 1) l1_s4 l1_s6)))))+  (let ((l1_s8 (ite (or (< l1_s0 0) (<= 3 l1_s0)) l1_s7 (table0 l1_s0))))+  l1_s8))))))))))
+ SBVTestSuite/GoldFiles/nested1.gold view
@@ -0,0 +1,14 @@+CAUGHT EXCEPTION++Data.SBV: Mismatched contexts detected.+***+*** Current context: SBVContext (-531973508589804280)+*** Mixed with     : SBVContext (-7749304166575005736)+***+*** This happens if you call a proof-function (prove/sat/runSMT/isSatisfiable) etc.+*** while another one is in execution, or use results from one such call in another.+*** Please avoid such nested calls, all interactions should be from the same context.+*** See https://github.com/LeventErkok/sbv/issues/71 for several examples.++CallStack (from HasCallStack):+  error, called at ./Data/SBV/Core/Symbolic.hs:1934:48 in sbv-10.3-inplace:Data.SBV.Core.Symbolic
+ SBVTestSuite/GoldFiles/nested2.gold view
@@ -0,0 +1,14 @@+CAUGHT EXCEPTION++Data.SBV: Mismatched contexts detected.+***+*** Current context: SBVContext (-531973508589804280)+*** Mixed with     : SBVContext (-7749304166575005736)+***+*** This happens if you call a proof-function (prove/sat/runSMT/isSatisfiable) etc.+*** while another one is in execution, or use results from one such call in another.+*** Please avoid such nested calls, all interactions should be from the same context.+*** See https://github.com/LeventErkok/sbv/issues/71 for several examples.++CallStack (from HasCallStack):+  error, called at ./Data/SBV/Core/Symbolic.hs:1934:48 in sbv-10.3-inplace:Data.SBV.Core.Symbolic
+ SBVTestSuite/GoldFiles/nested3.gold view
@@ -0,0 +1,40 @@+** Calling: z3 -nw -in -smt2+[GOOD] ; Automatically generated by SBV. Do not edit.+[GOOD] (set-option :print-success true)+[GOOD] (set-option :global-declarations true)+[GOOD] (set-option :smtlib2_compliant true)+[GOOD] (set-option :diagnostic-output-channel "stdout")+[GOOD] (set-option :produce-models true)+[GOOD] (set-logic ALL) ; external query, using all logics.+[GOOD] ; --- uninterpreted sorts ---+[GOOD] ; --- tuples ---+[GOOD] ; --- sums ---+[GOOD] ; --- literal constants ---+[GOOD] ; --- top level inputs ---+[GOOD] (declare-fun s0 () Bool) ; tracks user variable "x"+[GOOD] ; --- constant tables ---+[GOOD] ; --- non-constant tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user defined functions ---+[GOOD] ; --- assignments ---+[GOOD] ; --- arrayDelayeds ---+[GOOD] ; --- arraySetups ---+[GOOD] ; --- delayedEqualities ---+[GOOD] ; --- formula ---+*** Solver   : Z3+*** Exit code: ExitSuccess+CAUGHT EXCEPTION++Data.SBV: Mismatched contexts detected.+***+*** Current context: SBVContext (-7749304166575005736)+*** Mixed with     : SBVContext (-531973508589804280)+***+*** This happens if you call a proof-function (prove/sat/runSMT/isSatisfiable) etc.+*** while another one is in execution, or use results from one such call in another.+*** Please avoid such nested calls, all interactions should be from the same context.+*** See https://github.com/LeventErkok/sbv/issues/71 for several examples.++CallStack (from HasCallStack):+  error, called at ./Data/SBV/Core/Symbolic.hs:1934:48 in sbv-10.3-inplace:Data.SBV.Core.Symbolic
+ SBVTestSuite/GoldFiles/nested4.gold view
@@ -0,0 +1,14 @@+CAUGHT EXCEPTION++Data.SBV: Mismatched contexts detected.+***+*** Current context: SBVContext (-7749304166575005736)+*** Mixed with     : SBVContext (-531973508589804280)+***+*** This happens if you call a proof-function (prove/sat/runSMT/isSatisfiable) etc.+*** while another one is in execution, or use results from one such call in another.+*** Please avoid such nested calls, all interactions should be from the same context.+*** See https://github.com/LeventErkok/sbv/issues/71 for several examples.++CallStack (from HasCallStack):+  error, called at ./Data/SBV/Core/Symbolic.hs:1934:48 in sbv-10.3-inplace:Data.SBV.Core.Symbolic
SBVTestSuite/GoldFiles/quantifiedB_0.gold view
@@ -5,7 +5,7 @@ [GOOD] (set-option :smtlib2_compliant true) [GOOD] (set-option :diagnostic-output-channel "stdout") [GOOD] (set-option :produce-models true)-[GOOD] (set-logic BV)+[GOOD] (set-logic ALL) ; has quantified booleans, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums ---
SBVTestSuite/GoldFiles/quantifiedB_1.gold view
@@ -5,7 +5,7 @@ [GOOD] (set-option :smtlib2_compliant true) [GOOD] (set-option :diagnostic-output-channel "stdout") [GOOD] (set-option :produce-models true)-[GOOD] (set-logic BV)+[GOOD] (set-logic ALL) ; has quantified booleans, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums ---
SBVTestSuite/GoldFiles/quantifiedB_2.gold view
@@ -5,7 +5,7 @@ [GOOD] (set-option :smtlib2_compliant true) [GOOD] (set-option :diagnostic-output-channel "stdout") [GOOD] (set-option :produce-models true)-[GOOD] (set-logic BV)+[GOOD] (set-logic ALL) ; has quantified booleans, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums ---
SBVTestSuite/GoldFiles/quantifiedB_3.gold view
@@ -5,7 +5,7 @@ [GOOD] (set-option :smtlib2_compliant true) [GOOD] (set-option :diagnostic-output-channel "stdout") [GOOD] (set-option :produce-models true)-[GOOD] (set-logic BV)+[GOOD] (set-logic ALL) ; has quantified booleans, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums ---@@ -32,9 +32,9 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (s0))-[RECV] ((s0 #x00))+[RECV] ((s0 #x01)) *** Solver   : Z3 *** Exit code: ExitSuccess  RESULT: Satisfiable. Model:-  s0 = 0 :: Word8+  s0 = 1 :: Word8
SBVTestSuite/GoldFiles/quantifiedB_4.gold view
@@ -5,7 +5,7 @@ [GOOD] (set-option :smtlib2_compliant true) [GOOD] (set-option :diagnostic-output-channel "stdout") [GOOD] (set-option :produce-models true)-[GOOD] (set-logic BV)+[GOOD] (set-logic ALL) ; has quantified booleans, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums ---
SBVTestSuite/GoldFiles/quantifiedB_5.gold view
@@ -5,7 +5,7 @@ [GOOD] (set-option :smtlib2_compliant true) [GOOD] (set-option :diagnostic-output-channel "stdout") [GOOD] (set-option :produce-models true)-[GOOD] (set-logic BV)+[GOOD] (set-logic ALL) ; has quantified booleans, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums ---
SBVTestSuite/GoldFiles/quantifiedB_6.gold view
@@ -5,7 +5,7 @@ [GOOD] (set-option :smtlib2_compliant true) [GOOD] (set-option :diagnostic-output-channel "stdout") [GOOD] (set-option :produce-models true)-[GOOD] (set-logic BV)+[GOOD] (set-logic ALL) ; has quantified booleans, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums ---
SBVTestSuite/GoldFiles/quantifiedB_7.gold view
@@ -5,7 +5,7 @@ [GOOD] (set-option :smtlib2_compliant true) [GOOD] (set-option :diagnostic-output-channel "stdout") [GOOD] (set-option :produce-models true)-[GOOD] (set-logic BV)+[GOOD] (set-logic ALL) ; has quantified booleans, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums ---
SBVTestSuite/GoldFiles/quantifiedB_8.gold view
@@ -5,7 +5,7 @@ [GOOD] (set-option :smtlib2_compliant true) [GOOD] (set-option :diagnostic-output-channel "stdout") [GOOD] (set-option :produce-models true)-[GOOD] (set-logic BV)+[GOOD] (set-logic ALL) ; has quantified booleans, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums ---
SBVTestSuite/GoldFiles/quantifiedB_9.gold view
@@ -5,7 +5,7 @@ [GOOD] (set-option :smtlib2_compliant true) [GOOD] (set-option :diagnostic-output-channel "stdout") [GOOD] (set-option :produce-models true)-[GOOD] (set-logic BV)+[GOOD] (set-logic ALL) ; has quantified booleans, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums ---
SBVTestSuite/GoldFiles/quantified_prove_existsexists_contradiction_p.gold view
@@ -5,7 +5,7 @@ [GOOD] (set-option :smtlib2_compliant true) [GOOD] (set-option :diagnostic-output-channel "stdout") [GOOD] (set-option :produce-models true)-[GOOD] (set-logic BV)+[GOOD] (set-logic ALL) ; has quantified booleans, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums ---
SBVTestSuite/GoldFiles/quantified_prove_existsexists_satisfiable_p.gold view
@@ -5,7 +5,7 @@ [GOOD] (set-option :smtlib2_compliant true) [GOOD] (set-option :diagnostic-output-channel "stdout") [GOOD] (set-option :produce-models true)-[GOOD] (set-logic BV)+[GOOD] (set-logic ALL) ; has quantified booleans, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums ---
SBVTestSuite/GoldFiles/quantified_prove_existsexists_thm_p.gold view
@@ -5,7 +5,7 @@ [GOOD] (set-option :smtlib2_compliant true) [GOOD] (set-option :diagnostic-output-channel "stdout") [GOOD] (set-option :produce-models true)-[GOOD] (set-logic BV)+[GOOD] (set-logic ALL) ; has quantified booleans, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums ---
SBVTestSuite/GoldFiles/quantified_prove_existsforall_contradiction_p.gold view
@@ -5,7 +5,7 @@ [GOOD] (set-option :smtlib2_compliant true) [GOOD] (set-option :diagnostic-output-channel "stdout") [GOOD] (set-option :produce-models true)-[GOOD] (set-logic BV)+[GOOD] (set-logic ALL) ; has quantified booleans, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums ---
SBVTestSuite/GoldFiles/quantified_prove_existsforall_satisfiable_p.gold view
@@ -5,7 +5,7 @@ [GOOD] (set-option :smtlib2_compliant true) [GOOD] (set-option :diagnostic-output-channel "stdout") [GOOD] (set-option :produce-models true)-[GOOD] (set-logic BV)+[GOOD] (set-logic ALL) ; has quantified booleans, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums ---
SBVTestSuite/GoldFiles/quantified_prove_existsforall_thm_p.gold view
@@ -5,7 +5,7 @@ [GOOD] (set-option :smtlib2_compliant true) [GOOD] (set-option :diagnostic-output-channel "stdout") [GOOD] (set-option :produce-models true)-[GOOD] (set-logic BV)+[GOOD] (set-logic ALL) ; has quantified booleans, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums ---
SBVTestSuite/GoldFiles/quantified_prove_forallexists_contradiction_p.gold view
@@ -5,7 +5,7 @@ [GOOD] (set-option :smtlib2_compliant true) [GOOD] (set-option :diagnostic-output-channel "stdout") [GOOD] (set-option :produce-models true)-[GOOD] (set-logic BV)+[GOOD] (set-logic ALL) ; has quantified booleans, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums ---
SBVTestSuite/GoldFiles/quantified_prove_forallexists_satisfiable_p.gold view
@@ -5,7 +5,7 @@ [GOOD] (set-option :smtlib2_compliant true) [GOOD] (set-option :diagnostic-output-channel "stdout") [GOOD] (set-option :produce-models true)-[GOOD] (set-logic BV)+[GOOD] (set-logic ALL) ; has quantified booleans, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums ---
SBVTestSuite/GoldFiles/quantified_prove_forallexists_thm_p.gold view
@@ -5,7 +5,7 @@ [GOOD] (set-option :smtlib2_compliant true) [GOOD] (set-option :diagnostic-output-channel "stdout") [GOOD] (set-option :produce-models true)-[GOOD] (set-logic BV)+[GOOD] (set-logic ALL) ; has quantified booleans, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums ---
SBVTestSuite/GoldFiles/quantified_prove_forallforall_contradiction_p.gold view
@@ -5,7 +5,7 @@ [GOOD] (set-option :smtlib2_compliant true) [GOOD] (set-option :diagnostic-output-channel "stdout") [GOOD] (set-option :produce-models true)-[GOOD] (set-logic BV)+[GOOD] (set-logic ALL) ; has quantified booleans, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums ---
SBVTestSuite/GoldFiles/quantified_prove_forallforall_satisfiable_p.gold view
@@ -5,7 +5,7 @@ [GOOD] (set-option :smtlib2_compliant true) [GOOD] (set-option :diagnostic-output-channel "stdout") [GOOD] (set-option :produce-models true)-[GOOD] (set-logic BV)+[GOOD] (set-logic ALL) ; has quantified booleans, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums ---
SBVTestSuite/GoldFiles/quantified_prove_forallforall_thm_p.gold view
@@ -5,7 +5,7 @@ [GOOD] (set-option :smtlib2_compliant true) [GOOD] (set-option :diagnostic-output-channel "stdout") [GOOD] (set-option :produce-models true)-[GOOD] (set-logic BV)+[GOOD] (set-logic ALL) ; has quantified booleans, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums ---
SBVTestSuite/GoldFiles/quantified_sat_existsexists_contradiction_c.gold view
@@ -5,7 +5,7 @@ [GOOD] (set-option :smtlib2_compliant true) [GOOD] (set-option :diagnostic-output-channel "stdout") [GOOD] (set-option :produce-models true)-[GOOD] (set-logic BV)+[GOOD] (set-logic ALL) ; has quantified booleans, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums ---
SBVTestSuite/GoldFiles/quantified_sat_existsexists_contradiction_p.gold view
@@ -5,7 +5,7 @@ [GOOD] (set-option :smtlib2_compliant true) [GOOD] (set-option :diagnostic-output-channel "stdout") [GOOD] (set-option :produce-models true)-[GOOD] (set-logic BV)+[GOOD] (set-logic ALL) ; has quantified booleans, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums ---
SBVTestSuite/GoldFiles/quantified_sat_existsexists_satisfiable_c.gold view
@@ -5,7 +5,7 @@ [GOOD] (set-option :smtlib2_compliant true) [GOOD] (set-option :diagnostic-output-channel "stdout") [GOOD] (set-option :produce-models true)-[GOOD] (set-logic BV)+[GOOD] (set-logic ALL) ; has quantified booleans, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums ---
SBVTestSuite/GoldFiles/quantified_sat_existsexists_satisfiable_p.gold view
@@ -5,7 +5,7 @@ [GOOD] (set-option :smtlib2_compliant true) [GOOD] (set-option :diagnostic-output-channel "stdout") [GOOD] (set-option :produce-models true)-[GOOD] (set-logic BV)+[GOOD] (set-logic ALL) ; has quantified booleans, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums ---
SBVTestSuite/GoldFiles/quantified_sat_existsexists_thm_c.gold view
@@ -5,7 +5,7 @@ [GOOD] (set-option :smtlib2_compliant true) [GOOD] (set-option :diagnostic-output-channel "stdout") [GOOD] (set-option :produce-models true)-[GOOD] (set-logic BV)+[GOOD] (set-logic ALL) ; has quantified booleans, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums ---
SBVTestSuite/GoldFiles/quantified_sat_existsexists_thm_p.gold view
@@ -5,7 +5,7 @@ [GOOD] (set-option :smtlib2_compliant true) [GOOD] (set-option :diagnostic-output-channel "stdout") [GOOD] (set-option :produce-models true)-[GOOD] (set-logic BV)+[GOOD] (set-logic ALL) ; has quantified booleans, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums ---
SBVTestSuite/GoldFiles/quantified_sat_existsforall_contradiction_c.gold view
@@ -5,7 +5,7 @@ [GOOD] (set-option :smtlib2_compliant true) [GOOD] (set-option :diagnostic-output-channel "stdout") [GOOD] (set-option :produce-models true)-[GOOD] (set-logic BV)+[GOOD] (set-logic ALL) ; has quantified booleans, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums ---
SBVTestSuite/GoldFiles/quantified_sat_existsforall_contradiction_p.gold view
@@ -5,7 +5,7 @@ [GOOD] (set-option :smtlib2_compliant true) [GOOD] (set-option :diagnostic-output-channel "stdout") [GOOD] (set-option :produce-models true)-[GOOD] (set-logic BV)+[GOOD] (set-logic ALL) ; has quantified booleans, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums ---
SBVTestSuite/GoldFiles/quantified_sat_existsforall_satisfiable_c.gold view
@@ -5,7 +5,7 @@ [GOOD] (set-option :smtlib2_compliant true) [GOOD] (set-option :diagnostic-output-channel "stdout") [GOOD] (set-option :produce-models true)-[GOOD] (set-logic BV)+[GOOD] (set-logic ALL) ; has quantified booleans, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums ---
SBVTestSuite/GoldFiles/quantified_sat_existsforall_satisfiable_p.gold view
@@ -5,7 +5,7 @@ [GOOD] (set-option :smtlib2_compliant true) [GOOD] (set-option :diagnostic-output-channel "stdout") [GOOD] (set-option :produce-models true)-[GOOD] (set-logic BV)+[GOOD] (set-logic ALL) ; has quantified booleans, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums ---
SBVTestSuite/GoldFiles/quantified_sat_existsforall_thm_c.gold view
@@ -5,7 +5,7 @@ [GOOD] (set-option :smtlib2_compliant true) [GOOD] (set-option :diagnostic-output-channel "stdout") [GOOD] (set-option :produce-models true)-[GOOD] (set-logic BV)+[GOOD] (set-logic ALL) ; has quantified booleans, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums ---
SBVTestSuite/GoldFiles/quantified_sat_existsforall_thm_p.gold view
@@ -5,7 +5,7 @@ [GOOD] (set-option :smtlib2_compliant true) [GOOD] (set-option :diagnostic-output-channel "stdout") [GOOD] (set-option :produce-models true)-[GOOD] (set-logic BV)+[GOOD] (set-logic ALL) ; has quantified booleans, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums ---
SBVTestSuite/GoldFiles/quantified_sat_forallexists_contradiction_c.gold view
@@ -5,7 +5,7 @@ [GOOD] (set-option :smtlib2_compliant true) [GOOD] (set-option :diagnostic-output-channel "stdout") [GOOD] (set-option :produce-models true)-[GOOD] (set-logic BV)+[GOOD] (set-logic ALL) ; has quantified booleans, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums ---
SBVTestSuite/GoldFiles/quantified_sat_forallexists_contradiction_p.gold view
@@ -5,7 +5,7 @@ [GOOD] (set-option :smtlib2_compliant true) [GOOD] (set-option :diagnostic-output-channel "stdout") [GOOD] (set-option :produce-models true)-[GOOD] (set-logic BV)+[GOOD] (set-logic ALL) ; has quantified booleans, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums ---
SBVTestSuite/GoldFiles/quantified_sat_forallexists_satisfiable_c.gold view
@@ -5,7 +5,7 @@ [GOOD] (set-option :smtlib2_compliant true) [GOOD] (set-option :diagnostic-output-channel "stdout") [GOOD] (set-option :produce-models true)-[GOOD] (set-logic BV)+[GOOD] (set-logic ALL) ; has quantified booleans, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums ---
SBVTestSuite/GoldFiles/quantified_sat_forallexists_satisfiable_p.gold view
@@ -5,7 +5,7 @@ [GOOD] (set-option :smtlib2_compliant true) [GOOD] (set-option :diagnostic-output-channel "stdout") [GOOD] (set-option :produce-models true)-[GOOD] (set-logic BV)+[GOOD] (set-logic ALL) ; has quantified booleans, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums ---
SBVTestSuite/GoldFiles/quantified_sat_forallexists_thm_c.gold view
@@ -5,7 +5,7 @@ [GOOD] (set-option :smtlib2_compliant true) [GOOD] (set-option :diagnostic-output-channel "stdout") [GOOD] (set-option :produce-models true)-[GOOD] (set-logic BV)+[GOOD] (set-logic ALL) ; has quantified booleans, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums ---
SBVTestSuite/GoldFiles/quantified_sat_forallexists_thm_p.gold view
@@ -5,7 +5,7 @@ [GOOD] (set-option :smtlib2_compliant true) [GOOD] (set-option :diagnostic-output-channel "stdout") [GOOD] (set-option :produce-models true)-[GOOD] (set-logic BV)+[GOOD] (set-logic ALL) ; has quantified booleans, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums ---
SBVTestSuite/GoldFiles/quantified_sat_forallforall_contradiction_c.gold view
@@ -5,7 +5,7 @@ [GOOD] (set-option :smtlib2_compliant true) [GOOD] (set-option :diagnostic-output-channel "stdout") [GOOD] (set-option :produce-models true)-[GOOD] (set-logic BV)+[GOOD] (set-logic ALL) ; has quantified booleans, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums ---
SBVTestSuite/GoldFiles/quantified_sat_forallforall_contradiction_p.gold view
@@ -5,7 +5,7 @@ [GOOD] (set-option :smtlib2_compliant true) [GOOD] (set-option :diagnostic-output-channel "stdout") [GOOD] (set-option :produce-models true)-[GOOD] (set-logic BV)+[GOOD] (set-logic ALL) ; has quantified booleans, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums ---
SBVTestSuite/GoldFiles/quantified_sat_forallforall_satisfiable_c.gold view
@@ -5,7 +5,7 @@ [GOOD] (set-option :smtlib2_compliant true) [GOOD] (set-option :diagnostic-output-channel "stdout") [GOOD] (set-option :produce-models true)-[GOOD] (set-logic BV)+[GOOD] (set-logic ALL) ; has quantified booleans, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums ---
SBVTestSuite/GoldFiles/quantified_sat_forallforall_satisfiable_p.gold view
@@ -5,7 +5,7 @@ [GOOD] (set-option :smtlib2_compliant true) [GOOD] (set-option :diagnostic-output-channel "stdout") [GOOD] (set-option :produce-models true)-[GOOD] (set-logic BV)+[GOOD] (set-logic ALL) ; has quantified booleans, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums ---
SBVTestSuite/GoldFiles/quantified_sat_forallforall_thm_c.gold view
@@ -5,7 +5,7 @@ [GOOD] (set-option :smtlib2_compliant true) [GOOD] (set-option :diagnostic-output-channel "stdout") [GOOD] (set-option :produce-models true)-[GOOD] (set-logic BV)+[GOOD] (set-logic ALL) ; has quantified booleans, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums ---
SBVTestSuite/GoldFiles/quantified_sat_forallforall_thm_p.gold view
@@ -5,7 +5,7 @@ [GOOD] (set-option :smtlib2_compliant true) [GOOD] (set-option :diagnostic-output-channel "stdout") [GOOD] (set-option :produce-models true)-[GOOD] (set-logic BV)+[GOOD] (set-logic ALL) ; has quantified booleans, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums ---
SBVTestSuite/GoldFiles/query1.gold view
@@ -77,7 +77,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.12.3")+[RECV] (:version "4.12.5") [SEND] (get-info :status) [RECV] (:status sat) [GOOD] (define-fun s16 () Int 4)@@ -108,7 +108,7 @@ [SEND] (get-info :reason-unknown) [RECV] (:reason-unknown "unknown") [SEND] (get-info :version)-[RECV] (:version "4.12.3")+[RECV] (:version "4.12.5") [SEND] (get-info :memory) [RECV] unsupported [SEND] (get-info :time)
SBVTestSuite/GoldFiles/query_bitwuzla.gold view
@@ -1,4 +1,4 @@-** Calling: bitwuzla --smt2 -m --output-format=smt2 --no-exit-codes --incremental+** Calling: bitwuzla --produce-models [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)@@ -55,7 +55,3 @@ [RECV] ((s1 #b00000000000000000000000000000001)) *** Solver   : Bitwuzla *** Exit code: ExitSuccess-*** Std-out  : (-             (define-fun s0 () (_ BitVec 32) #b00000000000000000000000000000001)-             (define-fun s1 () (_ BitVec 32) #b00000000000000000000000000000001)-           )
SBVTestSuite/GoldFiles/query_uiSat_test1.gold view
@@ -35,6 +35,6 @@ [SEND] (get-value (q1)) [RECV] ((q1 (lambda ((x!1 Bool)) x!1))) -MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [], modelUIFuns = [("q1",(SBool -> SBool,Right ([([True :: Bool],True :: Bool)],False :: Bool)))]}+MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [], modelUIFuns = [("q1",(True,SBool -> SBool,Right ([([True :: Bool],True :: Bool)],False :: Bool)))]} DONE.*** Solver   : Z3 *** Exit code: ExitSuccess
SBVTestSuite/GoldFiles/query_uiSat_test2.gold view
@@ -40,6 +40,6 @@               false               true))) -MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [], modelUIFuns = [("q2",(SBool -> SBool -> SBool,Right ([([True :: Bool,False :: Bool],True :: Bool),([True :: Bool,True :: Bool],True :: Bool)],False :: Bool)))]}+MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [], modelUIFuns = [("q2",(True,SBool -> SBool -> SBool,Right ([([True :: Bool,False :: Bool],True :: Bool),([True :: Bool,True :: Bool],True :: Bool)],False :: Bool)))]} DONE.*** Solver   : Z3 *** Exit code: ExitSuccess
SBVTestSuite/GoldFiles/query_uisatex3.gold view
@@ -37,5 +37,5 @@ *** Exit code: ExitSuccess   FINAL:-"y x = 3 * x"+("y x = 3 * x",(True,Just ["x"],EApp [ECon "lambda",EApp [EApp [ECon "x!1",ECon "Int"]],EApp [ECon "*",ENum (3,Nothing),ECon "x!1"]])) DONE!
SBVTestSuite/GoldFiles/set_tupleSet.gold view
@@ -34,12 +34,11 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (s0))-[RECV] ((s0 (mkSBVTuple2 ((as const (Array Bool Bool)) true)-                    (store ((as const (Array Bool Bool)) false) false true))))+[RECV] ((s0 (mkSBVTuple2 (lambda ((x!1 Bool)) x!1) ((as const (Array Bool Bool)) true)))) *** Solver   : Z3 *** Exit code: ExitSuccess  FINAL: Satisfiable. Model:-  s0 = (U,{False}) :: ({Bool}, {Bool})+  s0 = ({True},U) :: ({Bool}, {Bool}) DONE!
SBVTestSuite/GoldFiles/set_uninterp1.gold view
@@ -64,9 +64,9 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (s0))-[RECV] ((s0 (store ((as const (Array E Bool)) false) C true)))+[RECV] ((s0 (store ((as const (Array E Bool)) true) A false))) [GOOD] (push 1)-[GOOD] (define-fun s10 () (Array E Bool) (store ((as const (Array E Bool)) false) C true))+[GOOD] (define-fun s10 () (Array E Bool) (store ((as const (Array E Bool)) true) A false)) [GOOD] (define-fun s11 () Bool (= s0 s10)) [GOOD] (define-fun s12 () Bool (not s11)) [GOOD] (assert s12)@@ -74,9 +74,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 ((as const (Array E Bool)) false) C true))) [GOOD] (push 1)-[GOOD] (define-fun s13 () (Array E Bool) (store (store ((as const (Array E Bool)) false) C true) A true))+[GOOD] (define-fun s13 () (Array E Bool) (store ((as const (Array E Bool)) false) C true)) [GOOD] (define-fun s14 () Bool (= s0 s13)) [GOOD] (define-fun s15 () Bool (not s14)) [GOOD] (assert s15)@@ -84,9 +84,9 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (s0))-[RECV] ((s0 ((as const (Array E Bool)) true)))+[RECV] ((s0 (store (store ((as const (Array E Bool)) false) B true) A true))) [GOOD] (push 1)-[GOOD] (define-fun s16 () (Array E Bool) ((as const (Array E Bool)) true))+[GOOD] (define-fun s16 () (Array E Bool) (store (store ((as const (Array E Bool)) false) B true) A true)) [GOOD] (define-fun s17 () Bool (= s0 s16)) [GOOD] (define-fun s18 () Bool (not s17)) [GOOD] (assert s18)@@ -94,9 +94,9 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (s0))-[RECV] ((s0 (store (store ((as const (Array E Bool)) false) B true) A true)))+[RECV] ((s0 (store (store ((as const (Array E Bool)) false) C true) A true))) [GOOD] (push 1)-[GOOD] (define-fun s19 () (Array E Bool) (store (store ((as const (Array E Bool)) false) B true) A true))+[GOOD] (define-fun s19 () (Array E Bool) (store (store ((as const (Array E Bool)) false) C true) A true)) [GOOD] (define-fun s20 () Bool (= s0 s19)) [GOOD] (define-fun s21 () Bool (not s20)) [GOOD] (assert s21)@@ -104,9 +104,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 ((as const (Array E Bool)) true))) [GOOD] (push 1)-[GOOD] (define-fun s22 () (Array E Bool) (store (store ((as const (Array E Bool)) false) C true) B true))+[GOOD] (define-fun s22 () (Array E Bool) ((as const (Array E Bool)) true)) [GOOD] (define-fun s23 () Bool (= s0 s22)) [GOOD] (define-fun s24 () Bool (not s23)) [GOOD] (assert s24)@@ -126,15 +126,15 @@  FINAL: Solution #1:-  s0 = {B,C} :: {E}+  s0 = U :: {E} Solution #2:-  s0 = {A,B} :: {E}+  s0 = {A,C} :: {E} Solution #3:-  s0 = U :: {E}+  s0 = {A,B} :: {E} Solution #4:-  s0 = {A,C} :: {E}-Solution #5:   s0 = {C} :: {E}+Solution #5:+  s0 = U - {A} :: {E} Solution #6:   s0 = {B} :: {E} Solution #7:
SBVTestSuite/GoldFiles/tgen_c.gold view
@@ -41,16 +41,16 @@ } CTestTestVector;  CTestTestVector CTest[] = {-      {{0x06d79fd8UL, 0x96962508UL}, {0x9d6dc4e0UL, 0x70417ad0UL, 0x996736c0UL}}-    , {{0xf3dc6f98UL, 0xf76adb6bUL}, {0xeb474b03UL, 0xfc71942dUL, 0x5d89ac88UL}}+      {{0x96962508UL, 0xf3dc6f98UL}, {0x8a7294a0UL, 0xa2b9b570UL, 0xee1474c0UL}}     , {{0xb4538396UL, 0x8f338d9cUL}, {0x43871132UL, 0x251ff5faUL, 0xe33fcd68UL}}-    , {{0xde90db7fUL, 0xe017f69fUL}, {0xbea8d21eUL, 0xfe78e4e0UL, 0x474d5de1UL}}-    , {{0xe7510cb7UL, 0x5e8efd6dUL}, {0x45e00a24UL, 0x88c20f4aUL, 0xd69544ebUL}}+    , {{0xe017f69fUL, 0xe7510cb7UL}, {0xc7690356UL, 0xf8c6e9e8UL, 0xd1ffbfa9UL}}     , {{0x9847fd68UL, 0x1e671b39UL}, {0xb6af18a1UL, 0x79e0e22fUL, 0xa4996428UL}}-    , {{0x3cba5737UL, 0xb9a2eb19UL}, {0xf65d4250UL, 0x83176c1eUL, 0xec10015fUL}}-    , {{0x6eedc674UL, 0x33a50d69UL}, {0xa292d3ddUL, 0x3b48b90bUL, 0x975e4994UL}}+    , {{0xb9a2eb19UL, 0x6eedc674UL}, {0x2890b18dUL, 0x4ab524a5UL, 0x83ccdd54UL}}     , {{0x4f576647UL, 0x0058226eUL}, {0x4faf88b5UL, 0x4eff43d9UL, 0xdb8b6082UL}}-    , {{0xa240be50UL, 0x24ff2cd8UL}, {0xc73feb28UL, 0x7d419178UL, 0xd9065380UL}}+    , {{0x24ff2cd8UL, 0x466eb767UL}, {0x6b6de43fUL, 0xde907571UL, 0xa08972e8UL}}+    , {{0x08363d14UL, 0xdcfe4253UL}, {0xe5347f67UL, 0x2b37fac1UL, 0x6f2cf57cUL}}+    , {{0xeefac975UL, 0x45b9cecdUL}, {0x34b49842UL, 0xa940faa8UL, 0x4b7c78b1UL}}+    , {{0x2ee34d81UL, 0xdabd0994UL}, {0x09a05715UL, 0x542643edUL, 0x2b5f5794UL}} };  int CTestLength = 10;
SBVTestSuite/GoldFiles/tgen_forte.gold view
@@ -1,14 +1,14 @@ // Automatically generated by SBV. Do not edit! let ForteTest =    let c s = val [_, r] = str_split s "'" in map (\s. s == "1") (explode (string_tl r))-   in [ ((c "32'b00000110110101111001111111011000", c "32'b10010110100101100010010100001000"), (c "32'b10011101011011011100010011100000", c "32'b01110000010000010111101011010000", c "32'b10011001011001110011011011000000"))-      , ((c "32'b11110011110111000110111110011000", c "32'b11110111011010101101101101101011"), (c "32'b11101011010001110100101100000011", c "32'b11111100011100011001010000101101", c "32'b01011101100010011010110010001000"))+   in [ ((c "32'b10010110100101100010010100001000", c "32'b11110011110111000110111110011000"), (c "32'b10001010011100101001010010100000", c "32'b10100010101110011011010101110000", c "32'b11101110000101000111010011000000"))       , ((c "32'b10110100010100111000001110010110", c "32'b10001111001100111000110110011100"), (c "32'b01000011100001110001000100110010", c "32'b00100101000111111111010111111010", c "32'b11100011001111111100110101101000"))-      , ((c "32'b11011110100100001101101101111111", c "32'b11100000000101111111011010011111"), (c "32'b10111110101010001101001000011110", c "32'b11111110011110001110010011100000", c "32'b01000111010011010101110111100001"))-      , ((c "32'b11100111010100010000110010110111", c "32'b01011110100011101111110101101101"), (c "32'b01000101111000000000101000100100", c "32'b10001000110000100000111101001010", c "32'b11010110100101010100010011101011"))+      , ((c "32'b11100000000101111111011010011111", c "32'b11100111010100010000110010110111"), (c "32'b11000111011010010000001101010110", c "32'b11111000110001101110100111101000", c "32'b11010001111111111011111110101001"))       , ((c "32'b10011000010001111111110101101000", c "32'b00011110011001110001101100111001"), (c "32'b10110110101011110001100010100001", c "32'b01111001111000001110001000101111", c "32'b10100100100110010110010000101000"))-      , ((c "32'b00111100101110100101011100110111", c "32'b10111001101000101110101100011001"), (c "32'b11110110010111010100001001010000", c "32'b10000011000101110110110000011110", c "32'b11101100000100000000000101011111"))-      , ((c "32'b01101110111011011100011001110100", c "32'b00110011101001010000110101101001"), (c "32'b10100010100100101101001111011101", c "32'b00111011010010001011100100001011", c "32'b10010111010111100100100110010100"))+      , ((c "32'b10111001101000101110101100011001", c "32'b01101110111011011100011001110100"), (c "32'b00101000100100001011000110001101", c "32'b01001010101101010010010010100101", c "32'b10000011110011001101110101010100"))       , ((c "32'b01001111010101110110011001000111", c "32'b00000000010110000010001001101110"), (c "32'b01001111101011111000100010110101", c "32'b01001110111111110100001111011001", c "32'b11011011100010110110000010000010"))-      , ((c "32'b10100010010000001011111001010000", c "32'b00100100111111110010110011011000"), (c "32'b11000111001111111110101100101000", c "32'b01111101010000011001000101111000", c "32'b11011001000001100101001110000000"))+      , ((c "32'b00100100111111110010110011011000", c "32'b01000110011011101011011101100111"), (c "32'b01101011011011011110010000111111", c "32'b11011110100100000111010101110001", c "32'b10100000100010010111001011101000"))+      , ((c "32'b00001000001101100011110100010100", c "32'b11011100111111100100001001010011"), (c "32'b11100101001101000111111101100111", c "32'b00101011001101111111101011000001", c "32'b01101111001011001111010101111100"))+      , ((c "32'b11101110111110101100100101110101", c "32'b01000101101110011100111011001101"), (c "32'b00110100101101001001100001000010", c "32'b10101001010000001111101010101000", c "32'b01001011011111000111100010110001"))+      , ((c "32'b00101110111000110100110110000001", c "32'b11011010101111010000100110010100"), (c "32'b00001001101000000101011100010101", c "32'b01010100001001100100001111101101", c "32'b00101011010111110101011110010100"))       ];
SBVTestSuite/GoldFiles/tgen_haskell.gold view
@@ -5,14 +5,14 @@ import Data.Word  haskTest :: [([Word32], [Word32])]-haskTest = [ ([0x06d79fd8, 0x96962508], [0x9d6dc4e0, 0x70417ad0, 0x996736c0])-           , ([0xf3dc6f98, 0xf76adb6b], [0xeb474b03, 0xfc71942d, 0x5d89ac88])+haskTest = [ ([0x96962508, 0xf3dc6f98], [0x8a7294a0, 0xa2b9b570, 0xee1474c0])            , ([0xb4538396, 0x8f338d9c], [0x43871132, 0x251ff5fa, 0xe33fcd68])-           , ([0xde90db7f, 0xe017f69f], [0xbea8d21e, 0xfe78e4e0, 0x474d5de1])-           , ([0xe7510cb7, 0x5e8efd6d], [0x45e00a24, 0x88c20f4a, 0xd69544eb])+           , ([0xe017f69f, 0xe7510cb7], [0xc7690356, 0xf8c6e9e8, 0xd1ffbfa9])            , ([0x9847fd68, 0x1e671b39], [0xb6af18a1, 0x79e0e22f, 0xa4996428])-           , ([0x3cba5737, 0xb9a2eb19], [0xf65d4250, 0x83176c1e, 0xec10015f])-           , ([0x6eedc674, 0x33a50d69], [0xa292d3dd, 0x3b48b90b, 0x975e4994])+           , ([0xb9a2eb19, 0x6eedc674], [0x2890b18d, 0x4ab524a5, 0x83ccdd54])            , ([0x4f576647, 0x0058226e], [0x4faf88b5, 0x4eff43d9, 0xdb8b6082])-           , ([0xa240be50, 0x24ff2cd8], [0xc73feb28, 0x7d419178, 0xd9065380])+           , ([0x24ff2cd8, 0x466eb767], [0x6b6de43f, 0xde907571, 0xa08972e8])+           , ([0x08363d14, 0xdcfe4253], [0xe5347f67, 0x2b37fac1, 0x6f2cf57c])+           , ([0xeefac975, 0x45b9cecd], [0x34b49842, 0xa940faa8, 0x4b7c78b1])+           , ([0x2ee34d81, 0xdabd0994], [0x09a05715, 0x542643ed, 0x2b5f5794])            ]
SBVTestSuite/GoldFiles/uiSat_test2.gold view
@@ -89,10 +89,14 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q2))-[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) false) true true true)))+[RECV] ((q2 (store (store ((as const (Array Bool Bool Bool)) false) false true true)+              true+              true+              true))) [GOOD] (define-fun q2_model5 ((x!0 Bool) (x!1 Bool)) Bool           (ite (and (= x!0 true) (= x!1 true)) true-          false)+          (ite (and (= x!0 false) (= x!1 true)) true+          false))        ) [GOOD] (define-fun q2_model5_reject () Bool           (exists ((x!0 Bool) (x!1 Bool))@@ -104,14 +108,10 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q2))-[RECV] ((q2 (store (store ((as const (Array Bool Bool Bool)) false) true true true)-              false-              true-              true)))+[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) false) true true true))) [GOOD] (define-fun q2_model6 ((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_model6_reject () Bool           (exists ((x!0 Bool) (x!1 Bool))@@ -210,13 +210,13 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q2))-[RECV] ((q2 (store (store ((as const (Array Bool Bool Bool)) true) true false false)+[RECV] ((q2 (store (store ((as const (Array Bool Bool Bool)) true) false true false)               true               true               false))) [GOOD] (define-fun q2_model12 ((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+          (ite (and (= x!0 false) (= x!1 true)) false           true))        ) [GOOD] (define-fun q2_model12_reject () Bool@@ -229,9 +229,9 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q2))-[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) true) true false false)))+[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) true) false true false))) [GOOD] (define-fun q2_model13 ((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)        ) [GOOD] (define-fun q2_model13_reject () Bool@@ -244,14 +244,10 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q2))-[RECV] ((q2 (store (store ((as const (Array Bool Bool Bool)) true) false true false)-              true-              true-              false)))+[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) true) true false false))) [GOOD] (define-fun q2_model14 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 true) (= x!1 true)) false-          (ite (and (= x!0 false) (= x!1 true)) false-          true))+          (ite (and (= x!0 true) (= x!1 false)) false+          true)        ) [GOOD] (define-fun q2_model14_reject () Bool           (exists ((x!0 Bool) (x!1 Bool))@@ -263,10 +259,14 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q2))-[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) true) false true false)))+[RECV] ((q2 (store (store ((as const (Array Bool Bool Bool)) true) true false false)+              true+              true+              false))) [GOOD] (define-fun q2_model15 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 false) (= x!1 true)) 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_model15_reject () Bool           (exists ((x!0 Bool) (x!1 Bool))@@ -301,22 +301,22 @@   q2 _    _    = True  Solution #2:   q2 :: Bool -> Bool -> Bool-  q2 False True = False-  q2 _     _    = True +  q2 True True  = False+  q2 True False = False+  q2 _    _     = True  Solution #3:   q2 :: Bool -> Bool -> Bool-  q2 True  True = False-  q2 False True = False-  q2 _     _    = True -Solution #4:-  q2 :: Bool -> Bool -> Bool   q2 True False = False   q2 _    _     = True +Solution #4:+  q2 :: Bool -> Bool -> Bool+  q2 False True = False+  q2 _     _    = True  Solution #5:   q2 :: Bool -> Bool -> Bool-  q2 True True  = False-  q2 True False = False-  q2 _    _     = True +  q2 True  True = False+  q2 False True = False+  q2 _     _    = True  Solution #6:   q2 :: Bool -> Bool -> Bool   q2 True  True  = True @@ -342,13 +342,13 @@   q2 _     _     = False Solution #11:   q2 :: Bool -> Bool -> Bool-  q2 False True = True -  q2 True  True = True -  q2 _     _    = False-Solution #12:-  q2 :: Bool -> Bool -> Bool   q2 True True = True    q2 _    _    = False+Solution #12:+  q2 :: Bool -> Bool -> Bool+  q2 True  True = True +  q2 False True = True +  q2 _     _    = False Solution #13:   q2 :: Bool -> Bool -> Bool   q2 False True = True
SBVTestSuite/GoldFiles/uiSat_test3.gold view
@@ -256,2072 +256,2072 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q1))-[RECV] ((q1 (lambda ((x!1 Bool)) x!1)))-[SEND] (get-value (q2))-[RECV] ((q2 (store (store ((as const (Array Bool Bool Bool)) true) true false false)-              true-              true-              false)))-[GOOD] (define-fun q1_model9 ((x!0 Bool)) Bool-          (ite (and (= x!0 true)) true-          false)-       )-[GOOD] (define-fun q1_model9_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1        x!0)-                            (q1_model9 x!0))))-[GOOD] (define-fun q2_model9 ((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_model9_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2        x!0 x!1)-                            (q2_model9 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_9 () Bool -               (or q1_model9_reject-                   q2_model9_reject-               ))-[GOOD] (assert uiFunRejector_model_9)-Looking for solution 10-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 ((as const (Array Bool Bool)) false)))-[SEND] (get-value (q2))-[RECV] ((q2 (store (store ((as const (Array Bool Bool Bool)) true) true false false)-              true-              true-              false)))-[GOOD] (define-fun q1_model10 ((x!0 Bool)) Bool-          false-       )-[GOOD] (define-fun q1_model10_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model10 x!0))))-[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))-       )-[GOOD] (define-fun q2_model10_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model10 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_10 () Bool -               (or q1_model10_reject-                   q2_model10_reject-               ))-[GOOD] (assert uiFunRejector_model_10)-Looking for solution 11-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 (store ((as const (Array Bool Bool)) false) false true)))-[SEND] (get-value (q2))-[RECV] ((q2 (store (store ((as const (Array Bool Bool Bool)) true) true false false)-              true-              true-              false)))-[GOOD] (define-fun q1_model11 ((x!0 Bool)) Bool-          (ite (and (= x!0 false)) true-          false)-       )-[GOOD] (define-fun q1_model11_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model11 x!0))))-[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))-       )-[GOOD] (define-fun q2_model11_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model11 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_11 () Bool -               (or q1_model11_reject-                   q2_model11_reject-               ))-[GOOD] (assert uiFunRejector_model_11)-Looking for solution 12-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 ((as const (Array Bool Bool)) true)))-[SEND] (get-value (q2))-[RECV] ((q2 (store (store ((as const (Array Bool Bool Bool)) true) true false false)-              true-              true-              false)))-[GOOD] (define-fun q1_model12 ((x!0 Bool)) Bool-          true-       )-[GOOD] (define-fun q1_model12_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model12 x!0))))-[GOOD] (define-fun q2_model12 ((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_model12_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model12 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_12 () Bool -               (or q1_model12_reject-                   q2_model12_reject-               ))-[GOOD] (assert uiFunRejector_model_12)-Looking for solution 13-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 (store ((as const (Array Bool Bool)) true) true false)))-[SEND] (get-value (q2))-[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) true) true false false)))-[GOOD] (define-fun q1_model13 ((x!0 Bool)) Bool-          (ite (and (= x!0 true)) false-          true)-       )-[GOOD] (define-fun q1_model13_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model13 x!0))))-[GOOD] (define-fun q2_model13 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 true) (= x!1 false)) false-          true)-       )-[GOOD] (define-fun q2_model13_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model13 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_13 () Bool -               (or q1_model13_reject-                   q2_model13_reject-               ))-[GOOD] (assert uiFunRejector_model_13)-Looking for solution 14-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 ((as const (Array Bool Bool)) true)))-[SEND] (get-value (q2))-[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) true) true false false)))-[GOOD] (define-fun q1_model14 ((x!0 Bool)) Bool-          true-       )-[GOOD] (define-fun q1_model14_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model14 x!0))))-[GOOD] (define-fun q2_model14 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 true) (= x!1 false)) false-          true)-       )-[GOOD] (define-fun q2_model14_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model14 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_14 () Bool -               (or q1_model14_reject-                   q2_model14_reject-               ))-[GOOD] (assert uiFunRejector_model_14)-Looking for solution 15-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 (store ((as const (Array Bool Bool)) true) true false)))-[SEND] (get-value (q2))-[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) false) false false true)))-[GOOD] (define-fun q1_model15 ((x!0 Bool)) Bool-          (ite (and (= x!0 true)) false-          true)-       )-[GOOD] (define-fun q1_model15_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model15 x!0))))-[GOOD] (define-fun q2_model15 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 false) (= x!1 false)) true-          false)-       )-[GOOD] (define-fun q2_model15_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model15 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_15 () Bool -               (or q1_model15_reject-                   q2_model15_reject-               ))-[GOOD] (assert uiFunRejector_model_15)-Looking for solution 16-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 (store ((as const (Array Bool Bool)) true) true false)))-[SEND] (get-value (q2))-[RECV] ((q2 (store (store ((as const (Array Bool Bool Bool)) false) false false true)-              true-              true-              true)))-[GOOD] (define-fun q1_model16 ((x!0 Bool)) Bool-          (ite (and (= x!0 true)) false-          true)-       )-[GOOD] (define-fun q1_model16_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model16 x!0))))-[GOOD] (define-fun q2_model16 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 true) (= x!1 true)) 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))-                  (distinct (q2         x!0 x!1)-                            (q2_model16 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_16 () Bool -               (or q1_model16_reject-                   q2_model16_reject-               ))-[GOOD] (assert uiFunRejector_model_16)-Looking for solution 17-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 (lambda ((x!1 Bool)) x!1)))-[SEND] (get-value (q2))-[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) false) false false true)))-[GOOD] (define-fun q1_model17 ((x!0 Bool)) Bool-          (ite (and (= x!0 true)) true-          false)-       )-[GOOD] (define-fun q1_model17_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model17 x!0))))-[GOOD] (define-fun q2_model17 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 false) (= x!1 false)) true-          false)-       )-[GOOD] (define-fun q2_model17_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model17 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_17 () Bool -               (or q1_model17_reject-                   q2_model17_reject-               ))-[GOOD] (assert uiFunRejector_model_17)-Looking for solution 18-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 ((as const (Array Bool Bool)) true)))-[SEND] (get-value (q2))-[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) false) false false true)))-[GOOD] (define-fun q1_model18 ((x!0 Bool)) Bool-          true-       )-[GOOD] (define-fun q1_model18_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model18 x!0))))-[GOOD] (define-fun q2_model18 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 false) (= x!1 false)) true-          false)-       )-[GOOD] (define-fun q2_model18_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model18 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_18 () Bool -               (or q1_model18_reject-                   q2_model18_reject-               ))-[GOOD] (assert uiFunRejector_model_18)-Looking for solution 19-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 ((as const (Array Bool Bool)) true)))-[SEND] (get-value (q2))-[RECV] ((q2 (store (store ((as const (Array Bool Bool Bool)) false) false false true)-              true-              true-              true)))-[GOOD] (define-fun q1_model19 ((x!0 Bool)) Bool-          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 true)) true-          (ite (and (= x!0 false) (= x!1 false)) true-          false))-       )-[GOOD] (define-fun q2_model19_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model19 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_19 () Bool -               (or q1_model19_reject-                   q2_model19_reject-               ))-[GOOD] (assert uiFunRejector_model_19)-Looking for solution 20-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 ((as const (Array Bool Bool)) true)))-[SEND] (get-value (q2))-[RECV] ((q2 (store (store ((as const (Array Bool Bool Bool)) false) false false true)-              true-              false-              true)))-[GOOD] (define-fun q1_model20 ((x!0 Bool)) Bool-          true-       )-[GOOD] (define-fun q1_model20_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model20 x!0))))-[GOOD] (define-fun q2_model20 ((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))-       )-[GOOD] (define-fun q2_model20_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model20 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_20 () Bool -               (or q1_model20_reject-                   q2_model20_reject-               ))-[GOOD] (assert uiFunRejector_model_20)-Looking for solution 21-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 ((as const (Array Bool Bool)) true)))-[SEND] (get-value (q2))-[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) true) false true false)))-[GOOD] (define-fun q1_model21 ((x!0 Bool)) Bool-          true-       )-[GOOD] (define-fun q1_model21_reject () Bool-          (exists ((x!0 Bool))-                  (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-          true)-       )-[GOOD] (define-fun q2_model21_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model21 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_21 () Bool -               (or q1_model21_reject-                   q2_model21_reject-               ))-[GOOD] (assert uiFunRejector_model_21)-Looking for solution 22-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 (lambda ((x!1 Bool)) x!1)))-[SEND] (get-value (q2))-[RECV] ((q2 (store (store ((as const (Array Bool Bool Bool)) false) false false true)-              true-              false-              true)))-[GOOD] (define-fun q1_model22 ((x!0 Bool)) Bool-          (ite (and (= x!0 true)) true-          false)-       )-[GOOD] (define-fun q1_model22_reject () Bool-          (exists ((x!0 Bool))-                  (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)) true-          (ite (and (= x!0 false) (= x!1 false)) true-          false))-       )-[GOOD] (define-fun q2_model22_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model22 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_22 () Bool -               (or q1_model22_reject-                   q2_model22_reject-               ))-[GOOD] (assert uiFunRejector_model_22)-Looking for solution 23-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 (lambda ((x!1 Bool)) x!1)))-[SEND] (get-value (q2))-[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) true) false true false)))-[GOOD] (define-fun q1_model23 ((x!0 Bool)) Bool-          (ite (and (= x!0 true)) true-          false)-       )-[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 false) (= x!1 true)) false-          true)-       )-[GOOD] (define-fun q2_model23_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model23 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_23 () Bool -               (or q1_model23_reject-                   q2_model23_reject-               ))-[GOOD] (assert uiFunRejector_model_23)-Looking for solution 24-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 (lambda ((x!1 Bool)) x!1)))-[SEND] (get-value (q2))-[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) true) true true false)))-[GOOD] (define-fun q1_model24 ((x!0 Bool)) Bool-          (ite (and (= x!0 true)) true-          false)-       )-[GOOD] (define-fun q1_model24_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (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-          true)-       )-[GOOD] (define-fun q2_model24_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model24 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_24 () Bool -               (or q1_model24_reject-                   q2_model24_reject-               ))-[GOOD] (assert uiFunRejector_model_24)-Looking for solution 25-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 ((as const (Array Bool Bool)) true)))-[SEND] (get-value (q2))-[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) true) true true false)))-[GOOD] (define-fun q1_model25 ((x!0 Bool)) Bool-          true-       )-[GOOD] (define-fun q1_model25_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model25 x!0))))-[GOOD] (define-fun q2_model25 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 true) (= x!1 true)) false-          true)-       )-[GOOD] (define-fun q2_model25_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model25 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_25 () Bool -               (or q1_model25_reject-                   q2_model25_reject-               ))-[GOOD] (assert uiFunRejector_model_25)-Looking for solution 26-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 (lambda ((x!1 Bool)) x!1)))-[SEND] (get-value (q2))-[RECV] ((q2 ((as const (Array Bool Bool Bool)) true)))-[GOOD] (define-fun q1_model26 ((x!0 Bool)) Bool-          (ite (and (= x!0 true)) true-          false)-       )-[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-          true-       )-[GOOD] (define-fun q2_model26_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model26 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_26 () Bool -               (or q1_model26_reject-                   q2_model26_reject-               ))-[GOOD] (assert uiFunRejector_model_26)-Looking for solution 27-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 (store ((as const (Array Bool Bool)) true) true false)))-[SEND] (get-value (q2))-[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) true) true true false)))-[GOOD] (define-fun q1_model27 ((x!0 Bool)) Bool-          (ite (and (= x!0 true)) false-          true)-       )-[GOOD] (define-fun q1_model27_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model27 x!0))))-[GOOD] (define-fun q2_model27 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 true) (= x!1 true)) false-          true)-       )-[GOOD] (define-fun q2_model27_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model27 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_27 () Bool -               (or q1_model27_reject-                   q2_model27_reject-               ))-[GOOD] (assert uiFunRejector_model_27)-Looking for solution 28-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 (store ((as const (Array Bool Bool)) true) true false)))-[SEND] (get-value (q2))-[RECV] ((q2 ((as const (Array Bool Bool Bool)) true)))-[GOOD] (define-fun q1_model28 ((x!0 Bool)) Bool-          (ite (and (= x!0 true)) false-          true)-       )-[GOOD] (define-fun q1_model28_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model28 x!0))))-[GOOD] (define-fun q2_model28 ((x!0 Bool) (x!1 Bool)) Bool-          true-       )-[GOOD] (define-fun q2_model28_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model28 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_28 () Bool -               (or q1_model28_reject-                   q2_model28_reject-               ))-[GOOD] (assert uiFunRejector_model_28)-Looking for solution 29-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 (store ((as const (Array Bool Bool)) true) true false)))-[SEND] (get-value (q2))-[RECV] ((q2 (store (store ((as const (Array Bool Bool Bool)) true) true true false)-              false-              true-              false)))-[GOOD] (define-fun q1_model29 ((x!0 Bool)) Bool-          (ite (and (= x!0 true)) false-          true)-       )-[GOOD] (define-fun q1_model29_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model29 x!0))))-[GOOD] (define-fun q2_model29 ((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_model29_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model29 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_29 () Bool -               (or q1_model29_reject-                   q2_model29_reject-               ))-[GOOD] (assert uiFunRejector_model_29)-Looking for solution 30-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 (store ((as const (Array Bool Bool)) true) true false)))-[SEND] (get-value (q2))-[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) false) true true true)))-[GOOD] (define-fun q1_model30 ((x!0 Bool)) Bool-          (ite (and (= x!0 true)) false-          true)-       )-[GOOD] (define-fun q1_model30_reject () Bool-          (exists ((x!0 Bool))-                  (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 true)) true-          false)-       )-[GOOD] (define-fun q2_model30_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model30 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_30 () Bool -               (or q1_model30_reject-                   q2_model30_reject-               ))-[GOOD] (assert uiFunRejector_model_30)-Looking for solution 31-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 ((as const (Array Bool Bool)) false)))-[SEND] (get-value (q2))-[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) true) false true false)))-[GOOD] (define-fun q1_model31 ((x!0 Bool)) Bool-          false-       )-[GOOD] (define-fun q1_model31_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model31 x!0))))-[GOOD] (define-fun q2_model31 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 false) (= x!1 true)) false-          true)-       )-[GOOD] (define-fun q2_model31_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model31 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_31 () Bool -               (or q1_model31_reject-                   q2_model31_reject-               ))-[GOOD] (assert uiFunRejector_model_31)-Looking for solution 32-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 (lambda ((x!1 Bool)) x!1)))-[SEND] (get-value (q2))-[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) false) false true true)))-[GOOD] (define-fun q1_model32 ((x!0 Bool)) Bool-          (ite (and (= x!0 true)) true-          false)-       )-[GOOD] (define-fun q1_model32_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model32 x!0))))-[GOOD] (define-fun q2_model32 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 false) (= x!1 true)) true-          false)-       )-[GOOD] (define-fun q2_model32_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model32 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_32 () Bool -               (or q1_model32_reject-                   q2_model32_reject-               ))-[GOOD] (assert uiFunRejector_model_32)-Looking for solution 33-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 ((as const (Array Bool Bool)) false)))-[SEND] (get-value (q2))-[RECV] ((q2 (store (store ((as const (Array Bool Bool Bool)) true) false true false)-              true-              true-              false)))-[GOOD] (define-fun q1_model33 ((x!0 Bool)) Bool-          false-       )-[GOOD] (define-fun q1_model33_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model33 x!0))))-[GOOD] (define-fun q2_model33 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 true) (= x!1 true)) false-          (ite (and (= x!0 false) (= x!1 true)) false-          true))-       )-[GOOD] (define-fun q2_model33_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model33 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_33 () Bool -               (or q1_model33_reject-                   q2_model33_reject-               ))-[GOOD] (assert uiFunRejector_model_33)-Looking for solution 34-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 ((as const (Array Bool Bool)) true)))-[SEND] (get-value (q2))-[RECV] ((q2 ((as const (Array Bool Bool Bool)) true)))-[GOOD] (define-fun q1_model34 ((x!0 Bool)) Bool-          true-       )-[GOOD] (define-fun q1_model34_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model34 x!0))))-[GOOD] (define-fun q2_model34 ((x!0 Bool) (x!1 Bool)) Bool-          true-       )-[GOOD] (define-fun q2_model34_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model34 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_34 () Bool -               (or q1_model34_reject-                   q2_model34_reject-               ))-[GOOD] (assert uiFunRejector_model_34)-Looking for solution 35-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 (lambda ((x!1 Bool)) x!1)))-[SEND] (get-value (q2))-[RECV] ((q2 ((as const (Array Bool Bool Bool)) false)))-[GOOD] (define-fun q1_model35 ((x!0 Bool)) Bool-          (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-          false-       )-[GOOD] (define-fun q2_model35_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model35 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_35 () Bool -               (or q1_model35_reject-                   q2_model35_reject-               ))-[GOOD] (assert uiFunRejector_model_35)-Looking for solution 36-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 (lambda ((x!1 Bool)) x!1)))-[SEND] (get-value (q2))-[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) false) true false true)))-[GOOD] (define-fun q1_model36 ((x!0 Bool)) Bool-          (ite (and (= x!0 true)) true-          false)-       )-[GOOD] (define-fun q1_model36_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model36 x!0))))-[GOOD] (define-fun q2_model36 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 true) (= x!1 false)) true-          false)-       )-[GOOD] (define-fun q2_model36_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model36 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_36 () Bool -               (or q1_model36_reject-                   q2_model36_reject-               ))-[GOOD] (assert uiFunRejector_model_36)-Looking for solution 37-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 (lambda ((x!1 Bool)) x!1)))-[SEND] (get-value (q2))-[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) true) false false false)))-[GOOD] (define-fun q1_model37 ((x!0 Bool)) Bool-          (ite (and (= x!0 true)) true-          false)-       )-[GOOD] (define-fun q1_model37_reject () Bool-          (exists ((x!0 Bool))-                  (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 false)) false-          true)-       )-[GOOD] (define-fun q2_model37_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model37 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_37 () Bool -               (or q1_model37_reject-                   q2_model37_reject-               ))-[GOOD] (assert uiFunRejector_model_37)-Looking for solution 38-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 (store ((as const (Array Bool Bool)) true) true false)))-[SEND] (get-value (q2))-[RECV] ((q2 (store (store ((as const (Array Bool Bool Bool)) false) true false true)-              false-              true-              true)))-[GOOD] (define-fun q1_model38 ((x!0 Bool)) Bool-          (ite (and (= x!0 true)) false-          true)-       )-[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 true)) true-          (ite (and (= x!0 true) (= x!1 false)) true-          false))-       )-[GOOD] (define-fun q2_model38_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model38 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_38 () Bool -               (or q1_model38_reject-                   q2_model38_reject-               ))-[GOOD] (assert uiFunRejector_model_38)-Looking for solution 39-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 ((as const (Array Bool Bool)) false)))-[SEND] (get-value (q2))-[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) false) false true true)))-[GOOD] (define-fun q1_model39 ((x!0 Bool)) Bool-          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)-       )-[GOOD] (define-fun q2_model39_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model39 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_39 () Bool -               (or q1_model39_reject-                   q2_model39_reject-               ))-[GOOD] (assert uiFunRejector_model_39)-Looking for solution 40-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 ((as const (Array Bool Bool)) false)))-[SEND] (get-value (q2))-[RECV] ((q2 (store (store ((as const (Array Bool Bool Bool)) false) false true true)-              true-              false-              true)))-[GOOD] (define-fun q1_model40 ((x!0 Bool)) Bool-          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 true) (= x!1 false)) true-          (ite (and (= x!0 false) (= x!1 true)) true-          false))-       )-[GOOD] (define-fun q2_model40_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model40 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_40 () Bool -               (or q1_model40_reject-                   q2_model40_reject-               ))-[GOOD] (assert uiFunRejector_model_40)-Looking for solution 41-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 (lambda ((x!1 Bool)) x!1)))-[SEND] (get-value (q2))-[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) false) true true true)))-[GOOD] (define-fun q1_model41 ((x!0 Bool)) Bool-          (ite (and (= x!0 true)) true-          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-          false)-       )-[GOOD] (define-fun q2_model41_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model41 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_41 () Bool -               (or q1_model41_reject-                   q2_model41_reject-               ))-[GOOD] (assert uiFunRejector_model_41)-Looking for solution 42-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 (lambda ((x!1 Bool)) x!1)))-[SEND] (get-value (q2))-[RECV] ((q2 (store (store ((as const (Array Bool Bool Bool)) true) false false false)-              true-              false-              false)))-[GOOD] (define-fun q1_model42 ((x!0 Bool)) Bool-          (ite (and (= x!0 true)) 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 true) (= x!1 false)) 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))-                  (distinct (q2         x!0 x!1)-                            (q2_model42 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_42 () Bool -               (or q1_model42_reject-                   q2_model42_reject-               ))-[GOOD] (assert uiFunRejector_model_42)-Looking for solution 43-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 ((as const (Array Bool Bool)) false)))-[SEND] (get-value (q2))-[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) false) true false true)))-[GOOD] (define-fun q1_model43 ((x!0 Bool)) Bool-          false-       )-[GOOD] (define-fun q1_model43_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model43 x!0))))-[GOOD] (define-fun q2_model43 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 true) (= x!1 false)) true-          false)-       )-[GOOD] (define-fun q2_model43_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model43 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_43 () Bool -               (or q1_model43_reject-                   q2_model43_reject-               ))-[GOOD] (assert uiFunRejector_model_43)-Looking for solution 44-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 (lambda ((x!1 Bool)) x!1)))-[SEND] (get-value (q2))-[RECV] ((q2 (store (store ((as const (Array Bool Bool Bool)) true) false false false)-              true-              true-              false)))-[GOOD] (define-fun q1_model44 ((x!0 Bool)) Bool-          (ite (and (= x!0 true)) 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))-       )-[GOOD] (define-fun q2_model44_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model44 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_44 () Bool -               (or q1_model44_reject-                   q2_model44_reject-               ))-[GOOD] (assert uiFunRejector_model_44)-Looking for solution 45-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 ((as const (Array Bool Bool)) false)))-[SEND] (get-value (q2))-[RECV] ((q2 (store (store ((as const (Array Bool Bool Bool)) false) false true true)-              true-              true-              true)))-[GOOD] (define-fun q1_model45 ((x!0 Bool)) Bool-          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 true) (= x!1 true)) true-          (ite (and (= x!0 false) (= x!1 true)) true-          false))-       )-[GOOD] (define-fun q2_model45_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model45 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_45 () Bool -               (or q1_model45_reject-                   q2_model45_reject-               ))-[GOOD] (assert uiFunRejector_model_45)-Looking for solution 46-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 ((as const (Array Bool Bool)) false)))-[SEND] (get-value (q2))-[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) true) false false false)))-[GOOD] (define-fun q1_model46 ((x!0 Bool)) Bool-          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 false)) false-          true)-       )-[GOOD] (define-fun q2_model46_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model46 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_46 () Bool -               (or q1_model46_reject-                   q2_model46_reject-               ))-[GOOD] (assert uiFunRejector_model_46)-Looking for solution 47-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 ((as const (Array Bool Bool)) false)))-[SEND] (get-value (q2))-[RECV] ((q2 (store (store ((as const (Array Bool Bool Bool)) true) false false false)-              false-              true-              false)))-[GOOD] (define-fun q1_model47 ((x!0 Bool)) Bool-          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 false) (= x!1 true)) false-          (ite (and (= x!0 false) (= x!1 false)) false-          true))-       )-[GOOD] (define-fun q2_model47_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model47 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_47 () Bool -               (or q1_model47_reject-                   q2_model47_reject-               ))-[GOOD] (assert uiFunRejector_model_47)-Looking for solution 48-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 (lambda ((x!1 Bool)) x!1)))-[SEND] (get-value (q2))-[RECV] ((q2 (store (store ((as const (Array Bool Bool Bool)) true) false false false)-              false-              true-              false)))-[GOOD] (define-fun q1_model48 ((x!0 Bool)) Bool-          (ite (and (= x!0 true)) 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 false) (= x!1 true)) false-          (ite (and (= x!0 false) (= x!1 false)) false-          true))-       )-[GOOD] (define-fun q2_model48_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model48 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_48 () Bool -               (or q1_model48_reject-                   q2_model48_reject-               ))-[GOOD] (assert uiFunRejector_model_48)-Looking for solution 49-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 ((as const (Array Bool Bool)) false)))-[SEND] (get-value (q2))-[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) false) true true true)))-[GOOD] (define-fun q1_model49 ((x!0 Bool)) Bool-          false-       )-[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 true)) true-          false)-       )-[GOOD] (define-fun q2_model49_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model49 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_49 () Bool -               (or q1_model49_reject-                   q2_model49_reject-               ))-[GOOD] (assert uiFunRejector_model_49)-Looking for solution 50-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 ((as const (Array Bool Bool)) true)))-[SEND] (get-value (q2))-[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) false) true true true)))-[GOOD] (define-fun q1_model50 ((x!0 Bool)) Bool-          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-          false)-       )-[GOOD] (define-fun q2_model50_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model50 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_50 () Bool -               (or q1_model50_reject-                   q2_model50_reject-               ))-[GOOD] (assert uiFunRejector_model_50)-Looking for solution 51-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 ((as const (Array Bool Bool)) true)))-[SEND] (get-value (q2))-[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) false) true false true)))-[GOOD] (define-fun q1_model51 ((x!0 Bool)) Bool-          true-       )-[GOOD] (define-fun q1_model51_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model51 x!0))))-[GOOD] (define-fun q2_model51 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 true) (= x!1 false)) true-          false)-       )-[GOOD] (define-fun q2_model51_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model51 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_51 () Bool -               (or q1_model51_reject-                   q2_model51_reject-               ))-[GOOD] (assert uiFunRejector_model_51)-Looking for solution 52-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 ((as const (Array Bool Bool)) true)))-[SEND] (get-value (q2))-[RECV] ((q2 (store (store ((as const (Array Bool Bool Bool)) false) true false true)-              true-              true-              true)))-[GOOD] (define-fun q1_model52 ((x!0 Bool)) Bool-          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-          (ite (and (= x!0 true) (= x!1 true)) true-          (ite (and (= x!0 true) (= x!1 false)) true-          false))-       )-[GOOD] (define-fun q2_model52_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model52 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_52 () Bool -               (or q1_model52_reject-                   q2_model52_reject-               ))-[GOOD] (assert uiFunRejector_model_52)-Looking for solution 53-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 ((as const (Array Bool Bool)) true)))-[SEND] (get-value (q2))-[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) true) false false false)))-[GOOD] (define-fun q1_model53 ((x!0 Bool)) Bool-          true-       )-[GOOD] (define-fun q1_model53_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model53 x!0))))-[GOOD] (define-fun q2_model53 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 false) (= x!1 false)) false-          true)-       )-[GOOD] (define-fun q2_model53_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model53 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_53 () Bool -               (or q1_model53_reject-                   q2_model53_reject-               ))-[GOOD] (assert uiFunRejector_model_53)-Looking for solution 54-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 ((as const (Array Bool Bool)) true)))-[SEND] (get-value (q2))-[RECV] ((q2 (store (store ((as const (Array Bool Bool Bool)) true) false false false)-              true-              false-              false)))-[GOOD] (define-fun q1_model54 ((x!0 Bool)) Bool-          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 true) (= x!1 false)) 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))-                  (distinct (q2         x!0 x!1)-                            (q2_model54 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_54 () Bool -               (or q1_model54_reject-                   q2_model54_reject-               ))-[GOOD] (assert uiFunRejector_model_54)-Looking for solution 55-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 (store ((as const (Array Bool Bool)) true) true false)))-[SEND] (get-value (q2))-[RECV] ((q2 (store (store ((as const (Array Bool Bool Bool)) true) false false false)-              true-              false-              false)))-[GOOD] (define-fun q1_model55 ((x!0 Bool)) Bool-          (ite (and (= x!0 true)) false-          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 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))-                  (distinct (q2         x!0 x!1)-                            (q2_model55 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_55 () Bool -               (or q1_model55_reject-                   q2_model55_reject-               ))-[GOOD] (assert uiFunRejector_model_55)-Looking for solution 56-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 (store ((as const (Array Bool Bool)) true) true false)))-[SEND] (get-value (q2))-[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) false) false true true)))-[GOOD] (define-fun q1_model56 ((x!0 Bool)) Bool-          (ite (and (= x!0 true)) false-          true)-       )-[GOOD] (define-fun q1_model56_reject () Bool-          (exists ((x!0 Bool))-                  (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)) true-          false)-       )-[GOOD] (define-fun q2_model56_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model56 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_56 () Bool -               (or q1_model56_reject-                   q2_model56_reject-               ))-[GOOD] (assert uiFunRejector_model_56)-Looking for solution 57-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 ((as const (Array Bool Bool)) true)))-[SEND] (get-value (q2))-[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) false) false true true)))-[GOOD] (define-fun q1_model57 ((x!0 Bool)) Bool-          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 false) (= x!1 true)) true-          false)-       )-[GOOD] (define-fun q2_model57_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model57 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_57 () Bool -               (or q1_model57_reject-                   q2_model57_reject-               ))-[GOOD] (assert uiFunRejector_model_57)-Looking for solution 58-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 ((as const (Array Bool Bool)) true)))-[SEND] (get-value (q2))-[RECV] ((q2 (store (store ((as const (Array Bool Bool Bool)) false) false true true)-              true-              false-              true)))-[GOOD] (define-fun q1_model58 ((x!0 Bool)) Bool-          true-       )-[GOOD] (define-fun q1_model58_reject () Bool-          (exists ((x!0 Bool))-                  (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)) true-          (ite (and (= x!0 false) (= x!1 true)) true-          false))-       )-[GOOD] (define-fun q2_model58_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model58 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_58 () Bool -               (or q1_model58_reject-                   q2_model58_reject-               ))-[GOOD] (assert uiFunRejector_model_58)-Looking for solution 59-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 (store ((as const (Array Bool Bool)) false) false true)))-[SEND] (get-value (q2))-[RECV] ((q2 ((as const (Array Bool Bool Bool)) false)))-[GOOD] (define-fun q1_model59 ((x!0 Bool)) Bool-          (ite (and (= x!0 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-          false-       )-[GOOD] (define-fun q2_model59_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model59 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_59 () Bool -               (or q1_model59_reject-                   q2_model59_reject-               ))-[GOOD] (assert uiFunRejector_model_59)-Looking for solution 60-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 (store ((as const (Array Bool Bool)) false) false true)))-[SEND] (get-value (q2))-[RECV] ((q2 (store (store ((as const (Array Bool Bool Bool)) true) false false false)-              false-              true-              false)))-[GOOD] (define-fun q1_model60 ((x!0 Bool)) Bool-          (ite (and (= x!0 false)) 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-          (ite (and (= x!0 false) (= x!1 true)) false-          (ite (and (= x!0 false) (= x!1 false)) false-          true))-       )-[GOOD] (define-fun q2_model60_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model60 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_60 () Bool -               (or q1_model60_reject-                   q2_model60_reject-               ))-[GOOD] (assert uiFunRejector_model_60)-Looking for solution 61-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 (store ((as const (Array Bool Bool)) true) true false)))-[SEND] (get-value (q2))-[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) false) true false true)))-[GOOD] (define-fun q1_model61 ((x!0 Bool)) Bool-          (ite (and (= x!0 true)) false-          true)-       )-[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 true) (= x!1 false)) true-          false)-       )-[GOOD] (define-fun q2_model61_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model61 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_61 () Bool -               (or q1_model61_reject-                   q2_model61_reject-               ))-[GOOD] (assert uiFunRejector_model_61)-Looking for solution 62-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 (store ((as const (Array Bool Bool)) true) true false)))-[SEND] (get-value (q2))-[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) true) false false false)))-[GOOD] (define-fun q1_model62 ((x!0 Bool)) Bool-          (ite (and (= x!0 true)) false-          true)-       )-[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 false) (= x!1 false)) false-          true)-       )-[GOOD] (define-fun q2_model62_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model62 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_62 () Bool -               (or q1_model62_reject-                   q2_model62_reject-               ))-[GOOD] (assert uiFunRejector_model_62)-Looking for solution 63-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 ((as const (Array Bool Bool)) false)))-[SEND] (get-value (q2))-[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) true) true true false)))-[GOOD] (define-fun q1_model63 ((x!0 Bool)) Bool-          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)-       )-[GOOD] (define-fun q2_model63_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model63 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_63 () Bool -               (or q1_model63_reject-                   q2_model63_reject-               ))-[GOOD] (assert uiFunRejector_model_63)-Looking for solution 64-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 (store ((as const (Array Bool Bool)) true) true false)))-[SEND] (get-value (q2))-[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) true) false true false)))-[GOOD] (define-fun q1_model64 ((x!0 Bool)) Bool-          (ite (and (= x!0 true)) false-          true)-       )-[GOOD] (define-fun q1_model64_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model64 x!0))))-[GOOD] (define-fun q2_model64 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 false) (= x!1 true)) false-          true)-       )-[GOOD] (define-fun q2_model64_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model64 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_64 () Bool -               (or q1_model64_reject-                   q2_model64_reject-               ))-[GOOD] (assert uiFunRejector_model_64)-Looking for solution 65-[SEND] (check-sat)-[RECV] unsat-*** Solver   : Z3-*** Exit code: ExitSuccess--RESULT: Solution #1:-  q1 :: Bool -> Bool-  q1 True = False-  q1 _    = True --  q2 :: Bool -> Bool -> Bool-  q2 False True = False-  q2 _     _    = True -Solution #2:-  q1 :: Bool -> Bool-  q1 _ = False--  q2 :: Bool -> Bool -> Bool-  q2 True True = False-  q2 _    _    = True -Solution #3:-  q1 :: Bool -> Bool-  q1 True = False-  q1 _    = True --  q2 :: Bool -> Bool -> Bool-  q2 False False = False-  q2 _     _     = True -Solution #4:-  q1 :: Bool -> Bool-  q1 True = False-  q1 _    = True --  q2 :: Bool -> Bool -> Bool-  q2 True False = True -  q2 _    _     = False-Solution #5:-  q1 :: Bool -> Bool-  q1 False = True -  q1 _     = False--  q2 :: Bool -> Bool -> Bool-  q2 False True  = False-  q2 False False = False-  q2 _     _     = True -Solution #6:-  q1 :: Bool -> Bool-  q1 False = True -  q1 _     = False--  q2 :: Bool -> Bool -> Bool-  q2 _ _ = False-Solution #7:-  q1 :: Bool -> Bool-  q1 _ = True--  q2 :: Bool -> Bool -> Bool-  q2 True  False = True -  q2 False True  = True -  q2 _     _     = False-Solution #8:-  q1 :: Bool -> Bool-  q1 _ = True--  q2 :: Bool -> Bool -> Bool-  q2 False True = True -  q2 _     _    = False-Solution #9:-  q1 :: Bool -> Bool-  q1 True = False-  q1 _    = True --  q2 :: Bool -> Bool -> Bool-  q2 False True = True -  q2 _     _    = False-Solution #10:-  q1 :: Bool -> Bool-  q1 True = False-  q1 _    = True --  q2 :: Bool -> Bool -> Bool-  q2 True  False = False-  q2 False False = False-  q2 _     _     = True -Solution #11:-  q1 :: Bool -> Bool-  q1 _ = True--  q2 :: Bool -> Bool -> Bool-  q2 True  False = False-  q2 False False = False-  q2 _     _     = True -Solution #12:-  q1 :: Bool -> Bool-  q1 _ = True--  q2 :: Bool -> Bool -> Bool-  q2 False False = False-  q2 _     _     = True -Solution #13:-  q1 :: Bool -> Bool-  q1 _ = True--  q2 :: Bool -> Bool -> Bool-  q2 True True  = True -  q2 True False = True -  q2 _    _     = False-Solution #14:-  q1 :: Bool -> Bool-  q1 _ = True--  q2 :: Bool -> Bool -> Bool-  q2 True False = True -  q2 _    _     = False-Solution #15:-  q1 :: Bool -> Bool-  q1 _ = True--  q2 :: Bool -> Bool -> Bool-  q2 True True = True -  q2 _    _    = False-Solution #16:-  q1 :: Bool -> Bool-  q1 _ = False--  q2 :: Bool -> Bool -> Bool-  q2 True True = True -  q2 _    _    = False-Solution #17:-  q1 :: Bool -> Bool-  q1 True = True -  q1 _    = False--  q2 :: Bool -> Bool -> Bool-  q2 False True  = False-  q2 False False = False-  q2 _     _     = True -Solution #18:-  q1 :: Bool -> Bool-  q1 _ = False--  q2 :: Bool -> Bool -> Bool-  q2 False True  = False-  q2 False False = False-  q2 _     _     = True -Solution #19:-  q1 :: Bool -> Bool-  q1 _ = False--  q2 :: Bool -> Bool -> Bool-  q2 False False = False-  q2 _     _     = True -Solution #20:-  q1 :: Bool -> Bool-  q1 _ = False--  q2 :: Bool -> Bool -> Bool-  q2 True  True = True -  q2 False True = True -  q2 _     _    = False-Solution #21:-  q1 :: Bool -> Bool-  q1 True = True -  q1 _    = False--  q2 :: Bool -> Bool -> Bool-  q2 True  True  = False-  q2 False False = False-  q2 _     _     = True -Solution #22:-  q1 :: Bool -> Bool-  q1 _ = False--  q2 :: Bool -> Bool -> Bool-  q2 True False = True -  q2 _    _     = False-Solution #23:-  q1 :: Bool -> Bool-  q1 True = True -  q1 _    = False--  q2 :: Bool -> Bool -> Bool-  q2 True  False = False-  q2 False False = False-  q2 _     _     = True -Solution #24:-  q1 :: Bool -> Bool-  q1 True = True -  q1 _    = False--  q2 :: Bool -> Bool -> Bool-  q2 True True = True -  q2 _    _    = False-Solution #25:-  q1 :: Bool -> Bool-  q1 _ = False--  q2 :: Bool -> Bool -> Bool-  q2 True  False = True -  q2 False True  = True -  q2 _     _     = False-Solution #26:-  q1 :: Bool -> Bool-  q1 _ = False--  q2 :: Bool -> Bool -> Bool-  q2 False True = True -  q2 _     _    = False-Solution #27:-  q1 :: Bool -> Bool-  q1 True = False-  q1 _    = True --  q2 :: Bool -> Bool -> Bool-  q2 False True  = True -  q2 True  False = True -  q2 _     _     = False-Solution #28:-  q1 :: Bool -> Bool-  q1 True = True -  q1 _    = False--  q2 :: Bool -> Bool -> Bool-  q2 False False = False-  q2 _     _     = True -Solution #29:-  q1 :: Bool -> Bool-  q1 True = True -  q1 _    = False--  q2 :: Bool -> Bool -> Bool-  q2 True False = True -  q2 _    _     = False-Solution #30:-  q1 :: Bool -> Bool-  q1 True = True -  q1 _    = False--  q2 :: Bool -> Bool -> Bool-  q2 _ _ = False-Solution #31:-  q1 :: Bool -> Bool-  q1 _ = True--  q2 :: Bool -> Bool -> Bool-  q2 _ _ = True-Solution #32:-  q1 :: Bool -> Bool-  q1 _ = False--  q2 :: Bool -> Bool -> Bool-  q2 True  True = False-  q2 False True = False-  q2 _     _    = True -Solution #33:-  q1 :: Bool -> Bool-  q1 True = True -  q1 _    = False--  q2 :: Bool -> Bool -> Bool-  q2 False True = True -  q2 _     _    = False-Solution #34:-  q1 :: Bool -> Bool-  q1 _ = False--  q2 :: Bool -> Bool -> Bool-  q2 False True = False-  q2 _     _    = True -Solution #35:-  q1 :: Bool -> Bool-  q1 True = False-  q1 _    = True --  q2 :: Bool -> Bool -> Bool-  q2 True True = True -  q2 _    _    = False-Solution #36:-  q1 :: Bool -> Bool-  q1 True = False-  q1 _    = True --  q2 :: Bool -> Bool -> Bool-  q2 False True = False-  q2 True  True = False-  q2 _     _    = True -Solution #37:-  q1 :: Bool -> Bool-  q1 True = False-  q1 _    = True --  q2 :: Bool -> Bool -> Bool-  q2 _ _ = True-Solution #38:-  q1 :: Bool -> Bool-  q1 True = False-  q1 _    = True --  q2 :: Bool -> Bool -> Bool-  q2 True True = False-  q2 _    _    = True -Solution #39:-  q1 :: Bool -> Bool-  q1 True = True -  q1 _    = False--  q2 :: Bool -> Bool -> Bool-  q2 _ _ = True-Solution #40:-  q1 :: Bool -> Bool-  q1 _ = True--  q2 :: Bool -> Bool -> Bool-  q2 True True = False-  q2 _    _    = True -Solution #41:-  q1 :: Bool -> Bool-  q1 True = True -  q1 _    = False--  q2 :: Bool -> Bool -> Bool-  q2 True True = False-  q2 _    _    = True -Solution #42:-  q1 :: Bool -> Bool-  q1 True = True -  q1 _    = False--  q2 :: Bool -> Bool -> Bool-  q2 False True = False-  q2 _     _    = True -Solution #43:-  q1 :: Bool -> Bool-  q1 True = True -  q1 _    = False--  q2 :: Bool -> Bool -> Bool-  q2 True  False = True -  q2 False False = True -  q2 _     _     = False-Solution #44:-  q1 :: Bool -> Bool-  q1 _ = True--  q2 :: Bool -> Bool -> Bool-  q2 False True = False-  q2 _     _    = True -Solution #45:-  q1 :: Bool -> Bool-  q1 _ = True--  q2 :: Bool -> Bool -> Bool-  q2 True  False = True -  q2 False False = True -  q2 _     _     = False-Solution #46:-  q1 :: Bool -> Bool-  q1 _ = True--  q2 :: Bool -> Bool -> Bool-  q2 True  True  = True -  q2 False False = True -  q2 _     _     = False-Solution #47:-  q1 :: Bool -> Bool-  q1 _ = True--  q2 :: Bool -> Bool -> Bool-  q2 False False = True -  q2 _     _     = False-Solution #48:-  q1 :: Bool -> Bool-  q1 True = True -  q1 _    = False--  q2 :: Bool -> Bool -> Bool-  q2 False False = True -  q2 _     _     = False-Solution #49:-  q1 :: Bool -> Bool-  q1 True = False-  q1 _    = True --  q2 :: Bool -> Bool -> Bool-  q2 True  True  = True -  q2 False False = True -  q2 _     _     = False-Solution #50:-  q1 :: Bool -> Bool-  q1 True = False-  q1 _    = True --  q2 :: Bool -> Bool -> Bool-  q2 False False = True -  q2 _     _     = False-Solution #51:-  q1 :: Bool -> Bool-  q1 _ = True--  q2 :: Bool -> Bool -> Bool-  q2 True False = False-  q2 _    _     = True -Solution #52:-  q1 :: Bool -> Bool-  q1 True = False-  q1 _    = True --  q2 :: Bool -> Bool -> Bool-  q2 True False = False-  q2 _    _     = True -Solution #53:-  q1 :: Bool -> Bool-  q1 _ = True--  q2 :: Bool -> Bool -> Bool-  q2 True True  = False-  q2 True False = False-  q2 _    _     = True -Solution #54:-  q1 :: Bool -> Bool-  q1 False = True -  q1 _     = False--  q2 :: Bool -> Bool -> Bool-  q2 True True  = False-  q2 True False = False-  q2 _    _     = True -Solution #55:-  q1 :: Bool -> Bool-  q1 _ = False--  q2 :: Bool -> Bool -> Bool-  q2 True True  = False-  q2 True False = False-  q2 _    _     = True -Solution #56:-  q1 :: Bool -> Bool-  q1 True = True -  q1 _    = False--  q2 :: Bool -> Bool -> Bool-  q2 True True  = False-  q2 True False = False-  q2 _    _     = True +[RECV] ((q1 (store ((as const (Array Bool Bool)) true) true false)))+[SEND] (get-value (q2))+[RECV] ((q2 (store (store ((as const (Array Bool Bool Bool)) false) false false true)+              true+              true+              true)))+[GOOD] (define-fun q1_model9 ((x!0 Bool)) Bool+          (ite (and (= x!0 true)) false+          true)+       )+[GOOD] (define-fun q1_model9_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1        x!0)+                            (q1_model9 x!0))))+[GOOD] (define-fun q2_model9 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 true) (= x!1 true)) true+          (ite (and (= x!0 false) (= x!1 false)) true+          false))+       )+[GOOD] (define-fun q2_model9_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2        x!0 x!1)+                            (q2_model9 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_9 () Bool +               (or q1_model9_reject+                   q2_model9_reject+               ))+[GOOD] (assert uiFunRejector_model_9)+Looking for solution 10+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 ((as const (Array Bool Bool)) true)))+[SEND] (get-value (q2))+[RECV] ((q2 (store (store ((as const (Array Bool Bool Bool)) false) false false true)+              true+              true+              true)))+[GOOD] (define-fun q1_model10 ((x!0 Bool)) Bool+          true+       )+[GOOD] (define-fun q1_model10_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model10 x!0))))+[GOOD] (define-fun q2_model10 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 true) (= x!1 true)) true+          (ite (and (= x!0 false) (= x!1 false)) true+          false))+       )+[GOOD] (define-fun q2_model10_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model10 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_10 () Bool +               (or q1_model10_reject+                   q2_model10_reject+               ))+[GOOD] (assert uiFunRejector_model_10)+Looking for solution 11+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 ((as const (Array Bool Bool)) false)))+[SEND] (get-value (q2))+[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) true) false true false)))+[GOOD] (define-fun q1_model11 ((x!0 Bool)) Bool+          false+       )+[GOOD] (define-fun q1_model11_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model11 x!0))))+[GOOD] (define-fun q2_model11 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 false) (= x!1 true)) false+          true)+       )+[GOOD] (define-fun q2_model11_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model11 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_11 () Bool +               (or q1_model11_reject+                   q2_model11_reject+               ))+[GOOD] (assert uiFunRejector_model_11)+Looking for solution 12+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 (lambda ((x!1 Bool)) x!1)))+[SEND] (get-value (q2))+[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) true) false true false)))+[GOOD] (define-fun q1_model12 ((x!0 Bool)) Bool+          (ite (and (= x!0 true)) true+          false)+       )+[GOOD] (define-fun q1_model12_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model12 x!0))))+[GOOD] (define-fun q2_model12 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 false) (= x!1 true)) false+          true)+       )+[GOOD] (define-fun q2_model12_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model12 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_12 () Bool +               (or q1_model12_reject+                   q2_model12_reject+               ))+[GOOD] (assert uiFunRejector_model_12)+Looking for solution 13+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 (store ((as const (Array Bool Bool)) false) false true)))+[SEND] (get-value (q2))+[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) true) false true false)))+[GOOD] (define-fun q1_model13 ((x!0 Bool)) Bool+          (ite (and (= x!0 false)) true+          false)+       )+[GOOD] (define-fun q1_model13_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model13 x!0))))+[GOOD] (define-fun q2_model13 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 false) (= x!1 true)) false+          true)+       )+[GOOD] (define-fun q2_model13_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model13 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_13 () Bool +               (or q1_model13_reject+                   q2_model13_reject+               ))+[GOOD] (assert uiFunRejector_model_13)+Looking for solution 14+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 ((as const (Array Bool Bool)) true)))+[SEND] (get-value (q2))+[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) true) false true false)))+[GOOD] (define-fun q1_model14 ((x!0 Bool)) Bool+          true+       )+[GOOD] (define-fun q1_model14_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model14 x!0))))+[GOOD] (define-fun q2_model14 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 false) (= x!1 true)) false+          true)+       )+[GOOD] (define-fun q2_model14_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model14 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_14 () Bool +               (or q1_model14_reject+                   q2_model14_reject+               ))+[GOOD] (assert uiFunRejector_model_14)+Looking for solution 15+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 (lambda ((x!1 Bool)) x!1)))+[SEND] (get-value (q2))+[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) false) false false true)))+[GOOD] (define-fun q1_model15 ((x!0 Bool)) Bool+          (ite (and (= x!0 true)) true+          false)+       )+[GOOD] (define-fun q1_model15_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model15 x!0))))+[GOOD] (define-fun q2_model15 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 false) (= x!1 false)) true+          false)+       )+[GOOD] (define-fun q2_model15_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model15 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_15 () Bool +               (or q1_model15_reject+                   q2_model15_reject+               ))+[GOOD] (assert uiFunRejector_model_15)+Looking for solution 16+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 (lambda ((x!1 Bool)) x!1)))+[SEND] (get-value (q2))+[RECV] ((q2 (store (store ((as const (Array Bool Bool Bool)) false) false false true)+              true+              false+              true)))+[GOOD] (define-fun q1_model16 ((x!0 Bool)) Bool+          (ite (and (= x!0 true)) true+          false)+       )+[GOOD] (define-fun q1_model16_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model16 x!0))))+[GOOD] (define-fun q2_model16 ((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))+       )+[GOOD] (define-fun q2_model16_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model16 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_16 () Bool +               (or q1_model16_reject+                   q2_model16_reject+               ))+[GOOD] (assert uiFunRejector_model_16)+Looking for solution 17+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 ((as const (Array Bool Bool)) false)))+[SEND] (get-value (q2))+[RECV] ((q2 (store (store ((as const (Array Bool Bool Bool)) true) false true false)+              true+              true+              false)))+[GOOD] (define-fun q1_model17 ((x!0 Bool)) Bool+          false+       )+[GOOD] (define-fun q1_model17_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model17 x!0))))+[GOOD] (define-fun q2_model17 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 true) (= x!1 true)) false+          (ite (and (= x!0 false) (= x!1 true)) false+          true))+       )+[GOOD] (define-fun q2_model17_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model17 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_17 () Bool +               (or q1_model17_reject+                   q2_model17_reject+               ))+[GOOD] (assert uiFunRejector_model_17)+Looking for solution 18+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 (lambda ((x!1 Bool)) x!1)))+[SEND] (get-value (q2))+[RECV] ((q2 (store (store ((as const (Array Bool Bool Bool)) true) true true false)+              true+              false+              false)))+[GOOD] (define-fun q1_model18 ((x!0 Bool)) Bool+          (ite (and (= x!0 true)) true+          false)+       )+[GOOD] (define-fun q1_model18_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model18 x!0))))+[GOOD] (define-fun q2_model18 ((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))+       )+[GOOD] (define-fun q2_model18_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model18 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_18 () Bool +               (or q1_model18_reject+                   q2_model18_reject+               ))+[GOOD] (assert uiFunRejector_model_18)+Looking for solution 19+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 (lambda ((x!1 Bool)) x!1)))+[SEND] (get-value (q2))+[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) true) true true false)))+[GOOD] (define-fun q1_model19 ((x!0 Bool)) Bool+          (ite (and (= x!0 true)) true+          false)+       )+[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 true)) false+          true)+       )+[GOOD] (define-fun q2_model19_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model19 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_19 () Bool +               (or q1_model19_reject+                   q2_model19_reject+               ))+[GOOD] (assert uiFunRejector_model_19)+Looking for solution 20+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 ((as const (Array Bool Bool)) false)))+[SEND] (get-value (q2))+[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) true) true true false)))+[GOOD] (define-fun q1_model20 ((x!0 Bool)) Bool+          false+       )+[GOOD] (define-fun q1_model20_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model20 x!0))))+[GOOD] (define-fun q2_model20 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 true) (= x!1 true)) false+          true)+       )+[GOOD] (define-fun q2_model20_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model20 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_20 () Bool +               (or q1_model20_reject+                   q2_model20_reject+               ))+[GOOD] (assert uiFunRejector_model_20)+Looking for solution 21+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 (lambda ((x!1 Bool)) x!1)))+[SEND] (get-value (q2))+[RECV] ((q2 ((as const (Array Bool Bool Bool)) true)))+[GOOD] (define-fun q1_model21 ((x!0 Bool)) Bool+          (ite (and (= x!0 true)) true+          false)+       )+[GOOD] (define-fun q1_model21_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model21 x!0))))+[GOOD] (define-fun q2_model21 ((x!0 Bool) (x!1 Bool)) Bool+          true+       )+[GOOD] (define-fun q2_model21_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model21 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_21 () Bool +               (or q1_model21_reject+                   q2_model21_reject+               ))+[GOOD] (assert uiFunRejector_model_21)+Looking for solution 22+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 ((as const (Array Bool Bool)) false)))+[SEND] (get-value (q2))+[RECV] ((q2 (store (store ((as const (Array Bool Bool Bool)) true) true true false)+              true+              false+              false)))+[GOOD] (define-fun q1_model22 ((x!0 Bool)) Bool+          false+       )+[GOOD] (define-fun q1_model22_reject () Bool+          (exists ((x!0 Bool))+                  (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))+       )+[GOOD] (define-fun q2_model22_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model22 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_22 () Bool +               (or q1_model22_reject+                   q2_model22_reject+               ))+[GOOD] (assert uiFunRejector_model_22)+Looking for solution 23+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 (store ((as const (Array Bool Bool)) true) true false)))+[SEND] (get-value (q2))+[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) false) false false true)))+[GOOD] (define-fun q1_model23 ((x!0 Bool)) Bool+          (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 false) (= x!1 false)) true+          false)+       )+[GOOD] (define-fun q2_model23_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model23 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_23 () Bool +               (or q1_model23_reject+                   q2_model23_reject+               ))+[GOOD] (assert uiFunRejector_model_23)+Looking for solution 24+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 (store ((as const (Array Bool Bool)) true) true false)))+[SEND] (get-value (q2))+[RECV] ((q2 (store (store ((as const (Array Bool Bool Bool)) false) false false true)+              true+              false+              true)))+[GOOD] (define-fun q1_model24 ((x!0 Bool)) Bool+          (ite (and (= x!0 true)) false+          true)+       )+[GOOD] (define-fun q1_model24_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model24 x!0))))+[GOOD] (define-fun q2_model24 ((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))+       )+[GOOD] (define-fun q2_model24_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model24 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_24 () Bool +               (or q1_model24_reject+                   q2_model24_reject+               ))+[GOOD] (assert uiFunRejector_model_24)+Looking for solution 25+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 ((as const (Array Bool Bool)) true)))+[SEND] (get-value (q2))+[RECV] ((q2 (store (store ((as const (Array Bool Bool Bool)) false) false false true)+              true+              false+              true)))+[GOOD] (define-fun q1_model25 ((x!0 Bool)) Bool+          true+       )+[GOOD] (define-fun q1_model25_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model25 x!0))))+[GOOD] (define-fun q2_model25 ((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))+       )+[GOOD] (define-fun q2_model25_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model25 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_25 () Bool +               (or q1_model25_reject+                   q2_model25_reject+               ))+[GOOD] (assert uiFunRejector_model_25)+Looking for solution 26+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 (lambda ((x!1 Bool)) x!1)))+[SEND] (get-value (q2))+[RECV] ((q2 ((as const (Array Bool Bool Bool)) false)))+[GOOD] (define-fun q1_model26 ((x!0 Bool)) Bool+          (ite (and (= x!0 true)) true+          false)+       )+[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+          false+       )+[GOOD] (define-fun q2_model26_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model26 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_26 () Bool +               (or q1_model26_reject+                   q2_model26_reject+               ))+[GOOD] (assert uiFunRejector_model_26)+Looking for solution 27+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 (lambda ((x!1 Bool)) x!1)))+[SEND] (get-value (q2))+[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) false) true false true)))+[GOOD] (define-fun q1_model27 ((x!0 Bool)) Bool+          (ite (and (= x!0 true)) true+          false)+       )+[GOOD] (define-fun q1_model27_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model27 x!0))))+[GOOD] (define-fun q2_model27 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 true) (= x!1 false)) true+          false)+       )+[GOOD] (define-fun q2_model27_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model27 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_27 () Bool +               (or q1_model27_reject+                   q2_model27_reject+               ))+[GOOD] (assert uiFunRejector_model_27)+Looking for solution 28+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 (lambda ((x!1 Bool)) x!1)))+[SEND] (get-value (q2))+[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) false) false true true)))+[GOOD] (define-fun q1_model28 ((x!0 Bool)) Bool+          (ite (and (= x!0 true)) true+          false)+       )+[GOOD] (define-fun q1_model28_reject () Bool+          (exists ((x!0 Bool))+                  (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 true)) true+          false)+       )+[GOOD] (define-fun q2_model28_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model28 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_28 () Bool +               (or q1_model28_reject+                   q2_model28_reject+               ))+[GOOD] (assert uiFunRejector_model_28)+Looking for solution 29+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 (lambda ((x!1 Bool)) x!1)))+[SEND] (get-value (q2))+[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) true) false false false)))+[GOOD] (define-fun q1_model29 ((x!0 Bool)) Bool+          (ite (and (= x!0 true)) true+          false)+       )+[GOOD] (define-fun q1_model29_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model29 x!0))))+[GOOD] (define-fun q2_model29 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 false) (= x!1 false)) false+          true)+       )+[GOOD] (define-fun q2_model29_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model29 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_29 () Bool +               (or q1_model29_reject+                   q2_model29_reject+               ))+[GOOD] (assert uiFunRejector_model_29)+Looking for solution 30+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 ((as const (Array Bool Bool)) false)))+[SEND] (get-value (q2))+[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) true) false false false)))+[GOOD] (define-fun q1_model30 ((x!0 Bool)) Bool+          false+       )+[GOOD] (define-fun q1_model30_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model30 x!0))))+[GOOD] (define-fun q2_model30 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 false) (= x!1 false)) false+          true)+       )+[GOOD] (define-fun q2_model30_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model30 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_30 () Bool +               (or q1_model30_reject+                   q2_model30_reject+               ))+[GOOD] (assert uiFunRejector_model_30)+Looking for solution 31+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 ((as const (Array Bool Bool)) false)))+[SEND] (get-value (q2))+[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) false) true false true)))+[GOOD] (define-fun q1_model31 ((x!0 Bool)) Bool+          false+       )+[GOOD] (define-fun q1_model31_reject () Bool+          (exists ((x!0 Bool))+                  (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 false)) true+          false)+       )+[GOOD] (define-fun q2_model31_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model31 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_31 () Bool +               (or q1_model31_reject+                   q2_model31_reject+               ))+[GOOD] (assert uiFunRejector_model_31)+Looking for solution 32+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 (lambda ((x!1 Bool)) x!1)))+[SEND] (get-value (q2))+[RECV] ((q2 (store (store ((as const (Array Bool Bool Bool)) true) false false false)+              true+              true+              false)))+[GOOD] (define-fun q1_model32 ((x!0 Bool)) Bool+          (ite (and (= x!0 true)) true+          false)+       )+[GOOD] (define-fun q1_model32_reject () Bool+          (exists ((x!0 Bool))+                  (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)) false+          (ite (and (= x!0 false) (= x!1 false)) false+          true))+       )+[GOOD] (define-fun q2_model32_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model32 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_32 () Bool +               (or q1_model32_reject+                   q2_model32_reject+               ))+[GOOD] (assert uiFunRejector_model_32)+Looking for solution 33+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 ((as const (Array Bool Bool)) false)))+[SEND] (get-value (q2))+[RECV] ((q2 (store (store ((as const (Array Bool Bool Bool)) false) true false true)+              false+              true+              true)))+[GOOD] (define-fun q1_model33 ((x!0 Bool)) Bool+          false+       )+[GOOD] (define-fun q1_model33_reject () Bool+          (exists ((x!0 Bool))+                  (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 true)) 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))+                  (distinct (q2         x!0 x!1)+                            (q2_model33 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_33 () Bool +               (or q1_model33_reject+                   q2_model33_reject+               ))+[GOOD] (assert uiFunRejector_model_33)+Looking for solution 34+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 ((as const (Array Bool Bool)) false)))+[SEND] (get-value (q2))+[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) false) false true true)))+[GOOD] (define-fun q1_model34 ((x!0 Bool)) Bool+          false+       )+[GOOD] (define-fun q1_model34_reject () Bool+          (exists ((x!0 Bool))+                  (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+          false)+       )+[GOOD] (define-fun q2_model34_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model34 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_34 () Bool +               (or q1_model34_reject+                   q2_model34_reject+               ))+[GOOD] (assert uiFunRejector_model_34)+Looking for solution 35+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 (lambda ((x!1 Bool)) x!1)))+[SEND] (get-value (q2))+[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) false) true true true)))+[GOOD] (define-fun q1_model35 ((x!0 Bool)) Bool+          (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+          false)+       )+[GOOD] (define-fun q2_model35_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model35 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_35 () Bool +               (or q1_model35_reject+                   q2_model35_reject+               ))+[GOOD] (assert uiFunRejector_model_35)+Looking for solution 36+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 ((as const (Array Bool Bool)) false)))+[SEND] (get-value (q2))+[RECV] ((q2 (store (store ((as const (Array Bool Bool Bool)) false) false true true)+              true+              true+              true)))+[GOOD] (define-fun q1_model36 ((x!0 Bool)) Bool+          false+       )+[GOOD] (define-fun q1_model36_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model36 x!0))))+[GOOD] (define-fun q2_model36 ((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))+       )+[GOOD] (define-fun q2_model36_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model36 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_36 () Bool +               (or q1_model36_reject+                   q2_model36_reject+               ))+[GOOD] (assert uiFunRejector_model_36)+Looking for solution 37+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 (lambda ((x!1 Bool)) x!1)))+[SEND] (get-value (q2))+[RECV] ((q2 (store (store ((as const (Array Bool Bool Bool)) true) false false false)+              false+              true+              false)))+[GOOD] (define-fun q1_model37 ((x!0 Bool)) Bool+          (ite (and (= x!0 true)) true+          false)+       )+[GOOD] (define-fun q1_model37_reject () Bool+          (exists ((x!0 Bool))+                  (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)) false+          (ite (and (= x!0 false) (= x!1 false)) false+          true))+       )+[GOOD] (define-fun q2_model37_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model37 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_37 () Bool +               (or q1_model37_reject+                   q2_model37_reject+               ))+[GOOD] (assert uiFunRejector_model_37)+Looking for solution 38+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 ((as const (Array Bool Bool)) false)))+[SEND] (get-value (q2))+[RECV] ((q2 (store (store ((as const (Array Bool Bool Bool)) false) true true true)+              true+              false+              true)))+[GOOD] (define-fun q1_model38 ((x!0 Bool)) Bool+          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 true) (= x!1 false)) true+          (ite (and (= x!0 true) (= x!1 true)) true+          false))+       )+[GOOD] (define-fun q2_model38_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model38 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_38 () Bool +               (or q1_model38_reject+                   q2_model38_reject+               ))+[GOOD] (assert uiFunRejector_model_38)+Looking for solution 39+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 (lambda ((x!1 Bool)) x!1)))+[SEND] (get-value (q2))+[RECV] ((q2 (store (store ((as const (Array Bool Bool Bool)) false) true true true)+              false+              true+              true)))+[GOOD] (define-fun q1_model39 ((x!0 Bool)) Bool+          (ite (and (= x!0 true)) 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+          (ite (and (= x!0 true) (= x!1 true)) true+          false))+       )+[GOOD] (define-fun q2_model39_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model39 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_39 () Bool +               (or q1_model39_reject+                   q2_model39_reject+               ))+[GOOD] (assert uiFunRejector_model_39)+Looking for solution 40+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 (store ((as const (Array Bool Bool)) true) true false)))+[SEND] (get-value (q2))+[RECV] ((q2 (store (store ((as const (Array Bool Bool Bool)) false) true true true)+              false+              true+              true)))+[GOOD] (define-fun q1_model40 ((x!0 Bool)) Bool+          (ite (and (= x!0 true)) false+          true)+       )+[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+          (ite (and (= x!0 true) (= x!1 true)) true+          false))+       )+[GOOD] (define-fun q2_model40_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model40 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_40 () Bool +               (or q1_model40_reject+                   q2_model40_reject+               ))+[GOOD] (assert uiFunRejector_model_40)+Looking for solution 41+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 (store ((as const (Array Bool Bool)) true) true false)))+[SEND] (get-value (q2))+[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) false) false true true)))+[GOOD] (define-fun q1_model41 ((x!0 Bool)) Bool+          (ite (and (= x!0 true)) false+          true)+       )+[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 false) (= x!1 true)) true+          false)+       )+[GOOD] (define-fun q2_model41_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model41 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_41 () Bool +               (or q1_model41_reject+                   q2_model41_reject+               ))+[GOOD] (assert uiFunRejector_model_41)+Looking for solution 42+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 ((as const (Array Bool Bool)) true)))+[SEND] (get-value (q2))+[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) false) false true true)))+[GOOD] (define-fun q1_model42 ((x!0 Bool)) Bool+          true+       )+[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)+       )+[GOOD] (define-fun q2_model42_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model42 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_42 () Bool +               (or q1_model42_reject+                   q2_model42_reject+               ))+[GOOD] (assert uiFunRejector_model_42)+Looking for solution 43+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 ((as const (Array Bool Bool)) true)))+[SEND] (get-value (q2))+[RECV] ((q2 (store (store ((as const (Array Bool Bool Bool)) false) false true true)+              true+              true+              true)))+[GOOD] (define-fun q1_model43 ((x!0 Bool)) Bool+          true+       )+[GOOD] (define-fun q1_model43_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (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))+       )+[GOOD] (define-fun q2_model43_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model43 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_43 () Bool +               (or q1_model43_reject+                   q2_model43_reject+               ))+[GOOD] (assert uiFunRejector_model_43)+Looking for solution 44+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 (store ((as const (Array Bool Bool)) true) true false)))+[SEND] (get-value (q2))+[RECV] ((q2 (store (store ((as const (Array Bool Bool Bool)) false) false true true)+              true+              false+              true)))+[GOOD] (define-fun q1_model44 ((x!0 Bool)) Bool+          (ite (and (= x!0 true)) false+          true)+       )+[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 false)) true+          (ite (and (= x!0 false) (= x!1 true)) true+          false))+       )+[GOOD] (define-fun q2_model44_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model44 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_44 () Bool +               (or q1_model44_reject+                   q2_model44_reject+               ))+[GOOD] (assert uiFunRejector_model_44)+Looking for solution 45+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 (store ((as const (Array Bool Bool)) true) true false)))+[SEND] (get-value (q2))+[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) true) false false false)))+[GOOD] (define-fun q1_model45 ((x!0 Bool)) Bool+          (ite (and (= x!0 true)) false+          true)+       )+[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)+       )+[GOOD] (define-fun q2_model45_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model45 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_45 () Bool +               (or q1_model45_reject+                   q2_model45_reject+               ))+[GOOD] (assert uiFunRejector_model_45)+Looking for solution 46+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 ((as const (Array Bool Bool)) true)))+[SEND] (get-value (q2))+[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) true) false false false)))+[GOOD] (define-fun q1_model46 ((x!0 Bool)) Bool+          true+       )+[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 false)) false+          true)+       )+[GOOD] (define-fun q2_model46_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model46 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_46 () Bool +               (or q1_model46_reject+                   q2_model46_reject+               ))+[GOOD] (assert uiFunRejector_model_46)+Looking for solution 47+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 ((as const (Array Bool Bool)) true)))+[SEND] (get-value (q2))+[RECV] ((q2 (store (store ((as const (Array Bool Bool Bool)) true) false false false)+              true+              true+              false)))+[GOOD] (define-fun q1_model47 ((x!0 Bool)) Bool+          true+       )+[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 true)) false+          (ite (and (= x!0 false) (= x!1 false)) false+          true))+       )+[GOOD] (define-fun q2_model47_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model47 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_47 () Bool +               (or q1_model47_reject+                   q2_model47_reject+               ))+[GOOD] (assert uiFunRejector_model_47)+Looking for solution 48+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 ((as const (Array Bool Bool)) true)))+[SEND] (get-value (q2))+[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) true) true true false)))+[GOOD] (define-fun q1_model48 ((x!0 Bool)) Bool+          true+       )+[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)) false+          true)+       )+[GOOD] (define-fun q2_model48_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model48 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_48 () Bool +               (or q1_model48_reject+                   q2_model48_reject+               ))+[GOOD] (assert uiFunRejector_model_48)+Looking for solution 49+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 ((as const (Array Bool Bool)) true)))+[SEND] (get-value (q2))+[RECV] ((q2 ((as const (Array Bool Bool Bool)) true)))+[GOOD] (define-fun q1_model49 ((x!0 Bool)) Bool+          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+          true+       )+[GOOD] (define-fun q2_model49_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model49 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_49 () Bool +               (or q1_model49_reject+                   q2_model49_reject+               ))+[GOOD] (assert uiFunRejector_model_49)+Looking for solution 50+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 (store ((as const (Array Bool Bool)) true) true false)))+[SEND] (get-value (q2))+[RECV] ((q2 ((as const (Array Bool Bool Bool)) true)))+[GOOD] (define-fun q1_model50 ((x!0 Bool)) Bool+          (ite (and (= x!0 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+          true+       )+[GOOD] (define-fun q2_model50_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model50 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_50 () Bool +               (or q1_model50_reject+                   q2_model50_reject+               ))+[GOOD] (assert uiFunRejector_model_50)+Looking for solution 51+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 (store ((as const (Array Bool Bool)) false) false true)))+[SEND] (get-value (q2))+[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) true) true false false)))+[GOOD] (define-fun q1_model51 ((x!0 Bool)) Bool+          (ite (and (= x!0 false)) true+          false)+       )+[GOOD] (define-fun q1_model51_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model51 x!0))))+[GOOD] (define-fun q2_model51 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 true) (= x!1 false)) false+          true)+       )+[GOOD] (define-fun q2_model51_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model51 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_51 () Bool +               (or q1_model51_reject+                   q2_model51_reject+               ))+[GOOD] (assert uiFunRejector_model_51)+Looking for solution 52+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 ((as const (Array Bool Bool)) true)))+[SEND] (get-value (q2))+[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) true) true false false)))+[GOOD] (define-fun q1_model52 ((x!0 Bool)) Bool+          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+          (ite (and (= x!0 true) (= x!1 false)) false+          true)+       )+[GOOD] (define-fun q2_model52_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model52 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_52 () Bool +               (or q1_model52_reject+                   q2_model52_reject+               ))+[GOOD] (assert uiFunRejector_model_52)+Looking for solution 53+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 ((as const (Array Bool Bool)) false)))+[SEND] (get-value (q2))+[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) false) true true true)))+[GOOD] (define-fun q1_model53 ((x!0 Bool)) Bool+          false+       )+[GOOD] (define-fun q1_model53_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model53 x!0))))+[GOOD] (define-fun q2_model53 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 true) (= x!1 true)) true+          false)+       )+[GOOD] (define-fun q2_model53_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model53 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_53 () Bool +               (or q1_model53_reject+                   q2_model53_reject+               ))+[GOOD] (assert uiFunRejector_model_53)+Looking for solution 54+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 (store ((as const (Array Bool Bool)) true) true false)))+[SEND] (get-value (q2))+[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) false) true false true)))+[GOOD] (define-fun q1_model54 ((x!0 Bool)) Bool+          (ite (and (= x!0 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 true) (= x!1 false)) true+          false)+       )+[GOOD] (define-fun q2_model54_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model54 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_54 () Bool +               (or q1_model54_reject+                   q2_model54_reject+               ))+[GOOD] (assert uiFunRejector_model_54)+Looking for solution 55+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 (store ((as const (Array Bool Bool)) true) true false)))+[SEND] (get-value (q2))+[RECV] ((q2 (store (store ((as const (Array Bool Bool Bool)) false) true false true)+              true+              true+              true)))+[GOOD] (define-fun q1_model55 ((x!0 Bool)) Bool+          (ite (and (= x!0 true)) false+          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))+       )+[GOOD] (define-fun q2_model55_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model55 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_55 () Bool +               (or q1_model55_reject+                   q2_model55_reject+               ))+[GOOD] (assert uiFunRejector_model_55)+Looking for solution 56+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 ((as const (Array Bool Bool)) true)))+[SEND] (get-value (q2))+[RECV] ((q2 (store (store ((as const (Array Bool Bool Bool)) false) true false true)+              true+              true+              true)))+[GOOD] (define-fun q1_model56 ((x!0 Bool)) Bool+          true+       )+[GOOD] (define-fun q1_model56_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model56 x!0))))+[GOOD] (define-fun q2_model56 ((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_model56_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model56 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_56 () Bool +               (or q1_model56_reject+                   q2_model56_reject+               ))+[GOOD] (assert uiFunRejector_model_56)+Looking for solution 57+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 ((as const (Array Bool Bool)) true)))+[SEND] (get-value (q2))+[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) false) true false true)))+[GOOD] (define-fun q1_model57 ((x!0 Bool)) Bool+          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)) true+          false)+       )+[GOOD] (define-fun q2_model57_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model57 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_57 () Bool +               (or q1_model57_reject+                   q2_model57_reject+               ))+[GOOD] (assert uiFunRejector_model_57)+Looking for solution 58+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 (store ((as const (Array Bool Bool)) true) true false)))+[SEND] (get-value (q2))+[RECV] ((q2 ((as const (Array Bool Bool Bool)) false)))+[GOOD] (define-fun q1_model58 ((x!0 Bool)) Bool+          (ite (and (= x!0 true)) false+          true)+       )+[GOOD] (define-fun q1_model58_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model58 x!0))))+[GOOD] (define-fun q2_model58 ((x!0 Bool) (x!1 Bool)) Bool+          false+       )+[GOOD] (define-fun q2_model58_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model58 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_58 () Bool +               (or q1_model58_reject+                   q2_model58_reject+               ))+[GOOD] (assert uiFunRejector_model_58)+Looking for solution 59+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 (store ((as const (Array Bool Bool)) true) true false)))+[SEND] (get-value (q2))+[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) false) true true true)))+[GOOD] (define-fun q1_model59 ((x!0 Bool)) Bool+          (ite (and (= x!0 true)) false+          true)+       )+[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+          (ite (and (= x!0 true) (= x!1 true)) true+          false)+       )+[GOOD] (define-fun q2_model59_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model59 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_59 () Bool +               (or q1_model59_reject+                   q2_model59_reject+               ))+[GOOD] (assert uiFunRejector_model_59)+Looking for solution 60+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 ((as const (Array Bool Bool)) true)))+[SEND] (get-value (q2))+[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) false) true true true)))+[GOOD] (define-fun q1_model60 ((x!0 Bool)) Bool+          true+       )+[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+          (ite (and (= x!0 true) (= x!1 true)) true+          false)+       )+[GOOD] (define-fun q2_model60_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model60 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_60 () Bool +               (or q1_model60_reject+                   q2_model60_reject+               ))+[GOOD] (assert uiFunRejector_model_60)+Looking for solution 61+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 ((as const (Array Bool Bool)) true)))+[SEND] (get-value (q2))+[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) false) false false true)))+[GOOD] (define-fun q1_model61 ((x!0 Bool)) Bool+          true+       )+[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)) true+          false)+       )+[GOOD] (define-fun q2_model61_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model61 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_61 () Bool +               (or q1_model61_reject+                   q2_model61_reject+               ))+[GOOD] (assert uiFunRejector_model_61)+Looking for solution 62+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 ((as const (Array Bool Bool)) true)))+[SEND] (get-value (q2))+[RECV] ((q2 (store (store ((as const (Array Bool Bool Bool)) false) false false true)+              false+              true+              true)))+[GOOD] (define-fun q1_model62 ((x!0 Bool)) Bool+          true+       )+[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 false) (= x!1 true)) true+          (ite (and (= x!0 false) (= x!1 false)) true+          false))+       )+[GOOD] (define-fun q2_model62_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model62 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_62 () Bool +               (or q1_model62_reject+                   q2_model62_reject+               ))+[GOOD] (assert uiFunRejector_model_62)+Looking for solution 63+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 (store ((as const (Array Bool Bool)) true) true false)))+[SEND] (get-value (q2))+[RECV] ((q2 (store (store ((as const (Array Bool Bool Bool)) false) false false true)+              false+              true+              true)))+[GOOD] (define-fun q1_model63 ((x!0 Bool)) Bool+          (ite (and (= x!0 true)) false+          true)+       )+[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 false) (= x!1 true)) true+          (ite (and (= x!0 false) (= x!1 false)) true+          false))+       )+[GOOD] (define-fun q2_model63_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model63 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_63 () Bool +               (or q1_model63_reject+                   q2_model63_reject+               ))+[GOOD] (assert uiFunRejector_model_63)+Looking for solution 64+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 (store ((as const (Array Bool Bool)) true) true false)))+[SEND] (get-value (q2))+[RECV] ((q2 (store ((as const (Array Bool Bool Bool)) true) true true false)))+[GOOD] (define-fun q1_model64 ((x!0 Bool)) Bool+          (ite (and (= x!0 true)) false+          true)+       )+[GOOD] (define-fun q1_model64_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model64 x!0))))+[GOOD] (define-fun q2_model64 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 true) (= x!1 true)) false+          true)+       )+[GOOD] (define-fun q2_model64_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model64 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_64 () Bool +               (or q1_model64_reject+                   q2_model64_reject+               ))+[GOOD] (assert uiFunRejector_model_64)+Looking for solution 65+[SEND] (check-sat)+[RECV] unsat+*** Solver   : Z3+*** Exit code: ExitSuccess++RESULT: Solution #1:+  q1 :: Bool -> Bool+  q1 True = False+  q1 _    = True ++  q2 :: Bool -> Bool -> Bool+  q2 True True = False+  q2 _    _    = True +Solution #2:+  q1 :: Bool -> Bool+  q1 True = False+  q1 _    = True ++  q2 :: Bool -> Bool -> Bool+  q2 False True  = True +  q2 False False = True +  q2 _     _     = False+Solution #3:+  q1 :: Bool -> Bool+  q1 _ = True++  q2 :: Bool -> Bool -> Bool+  q2 False True  = True +  q2 False False = True +  q2 _     _     = False+Solution #4:+  q1 :: Bool -> Bool+  q1 _ = True++  q2 :: Bool -> Bool -> Bool+  q2 False False = True +  q2 _     _     = False+Solution #5:+  q1 :: Bool -> Bool+  q1 _ = True++  q2 :: Bool -> Bool -> Bool+  q2 True True = True +  q2 _    _    = False+Solution #6:+  q1 :: Bool -> Bool+  q1 True = False+  q1 _    = True ++  q2 :: Bool -> Bool -> Bool+  q2 True True = True +  q2 _    _    = False+Solution #7:+  q1 :: Bool -> Bool+  q1 True = False+  q1 _    = True ++  q2 :: Bool -> Bool -> Bool+  q2 _ _ = False+Solution #8:+  q1 :: Bool -> Bool+  q1 _ = True++  q2 :: Bool -> Bool -> Bool+  q2 True False = True +  q2 _    _     = False+Solution #9:+  q1 :: Bool -> Bool+  q1 _ = True++  q2 :: Bool -> Bool -> Bool+  q2 True True  = True +  q2 True False = True +  q2 _    _     = False+Solution #10:+  q1 :: Bool -> Bool+  q1 True = False+  q1 _    = True ++  q2 :: Bool -> Bool -> Bool+  q2 True True  = True +  q2 True False = True +  q2 _    _     = False+Solution #11:+  q1 :: Bool -> Bool+  q1 True = False+  q1 _    = True ++  q2 :: Bool -> Bool -> Bool+  q2 True False = True +  q2 _    _     = False+Solution #12:+  q1 :: Bool -> Bool+  q1 _ = False++  q2 :: Bool -> Bool -> Bool+  q2 True True = True +  q2 _    _    = False+Solution #13:+  q1 :: Bool -> Bool+  q1 _ = True++  q2 :: Bool -> Bool -> Bool+  q2 True False = False+  q2 _    _     = True +Solution #14:+  q1 :: Bool -> Bool+  q1 False = True +  q1 _     = False++  q2 :: Bool -> Bool -> Bool+  q2 True False = False+  q2 _    _     = True +Solution #15:+  q1 :: Bool -> Bool+  q1 True = False+  q1 _    = True ++  q2 :: Bool -> Bool -> Bool+  q2 _ _ = True+Solution #16:+  q1 :: Bool -> Bool+  q1 _ = True++  q2 :: Bool -> Bool -> Bool+  q2 _ _ = True+Solution #17:+  q1 :: Bool -> Bool+  q1 _ = True++  q2 :: Bool -> Bool -> Bool+  q2 True True = False+  q2 _    _    = True +Solution #18:+  q1 :: Bool -> Bool+  q1 _ = True++  q2 :: Bool -> Bool -> Bool+  q2 True  True  = False+  q2 False False = False+  q2 _     _     = True +Solution #19:+  q1 :: Bool -> Bool+  q1 _ = True++  q2 :: Bool -> Bool -> Bool+  q2 False False = False+  q2 _     _     = True +Solution #20:+  q1 :: Bool -> Bool+  q1 True = False+  q1 _    = True ++  q2 :: Bool -> Bool -> Bool+  q2 False False = False+  q2 _     _     = True +Solution #21:+  q1 :: Bool -> Bool+  q1 True = False+  q1 _    = True ++  q2 :: Bool -> Bool -> Bool+  q2 True  False = True +  q2 False True  = True +  q2 _     _     = False+Solution #22:+  q1 :: Bool -> Bool+  q1 _ = True++  q2 :: Bool -> Bool -> Bool+  q2 True  True = True +  q2 False True = True +  q2 _     _    = False+Solution #23:+  q1 :: Bool -> Bool+  q1 _ = True++  q2 :: Bool -> Bool -> Bool+  q2 False True = True +  q2 _     _    = False+Solution #24:+  q1 :: Bool -> Bool+  q1 True = False+  q1 _    = True ++  q2 :: Bool -> Bool -> Bool+  q2 False True = True +  q2 _     _    = False+Solution #25:+  q1 :: Bool -> Bool+  q1 True = False+  q1 _    = True ++  q2 :: Bool -> Bool -> Bool+  q2 False True = True +  q2 True  True = True +  q2 _     _    = False+Solution #26:+  q1 :: Bool -> Bool+  q1 True = True +  q1 _    = False++  q2 :: Bool -> Bool -> Bool+  q2 False True = True +  q2 True  True = True +  q2 _     _    = False+Solution #27:+  q1 :: Bool -> Bool+  q1 _ = False++  q2 :: Bool -> Bool -> Bool+  q2 True False = True +  q2 True True  = True +  q2 _    _     = False+Solution #28:+  q1 :: Bool -> Bool+  q1 True = True +  q1 _    = False++  q2 :: Bool -> Bool -> Bool+  q2 False True  = False+  q2 False False = False+  q2 _     _     = True +Solution #29:+  q1 :: Bool -> Bool+  q1 _ = False++  q2 :: Bool -> Bool -> Bool+  q2 True  True = True +  q2 False True = True +  q2 _     _    = False+Solution #30:+  q1 :: Bool -> Bool+  q1 True = True +  q1 _    = False++  q2 :: Bool -> Bool -> Bool+  q2 True True = True +  q2 _    _    = False+Solution #31:+  q1 :: Bool -> Bool+  q1 _ = False++  q2 :: Bool -> Bool -> Bool+  q2 False True = True +  q2 _     _    = False+Solution #32:+  q1 :: Bool -> Bool+  q1 _ = False++  q2 :: Bool -> Bool -> Bool+  q2 False True  = True +  q2 True  False = True +  q2 _     _     = False+Solution #33:+  q1 :: Bool -> Bool+  q1 True = True +  q1 _    = False++  q2 :: Bool -> Bool -> Bool+  q2 True  True  = False+  q2 False False = False+  q2 _     _     = True +Solution #34:+  q1 :: Bool -> Bool+  q1 _ = False++  q2 :: Bool -> Bool -> Bool+  q2 True False = True +  q2 _    _     = False+Solution #35:+  q1 :: Bool -> Bool+  q1 _ = False++  q2 :: Bool -> Bool -> Bool+  q2 False False = False+  q2 _     _     = True +Solution #36:+  q1 :: Bool -> Bool+  q1 True = True +  q1 _    = False++  q2 :: Bool -> Bool -> Bool+  q2 False False = False+  q2 _     _     = True +Solution #37:+  q1 :: Bool -> Bool+  q1 True = True +  q1 _    = False++  q2 :: Bool -> Bool -> Bool+  q2 False True = True +  q2 _     _    = False+Solution #38:+  q1 :: Bool -> Bool+  q1 True = True +  q1 _    = False++  q2 :: Bool -> Bool -> Bool+  q2 True False = True +  q2 _    _     = False+Solution #39:+  q1 :: Bool -> Bool+  q1 True = True +  q1 _    = False++  q2 :: Bool -> Bool -> Bool+  q2 _ _ = False+Solution #40:+  q1 :: Bool -> Bool+  q1 _ = True++  q2 :: Bool -> Bool -> Bool+  q2 True  False = True +  q2 False False = True +  q2 _     _     = False+Solution #41:+  q1 :: Bool -> Bool+  q1 True = False+  q1 _    = True ++  q2 :: Bool -> Bool -> Bool+  q2 True  False = True +  q2 False False = True +  q2 _     _     = False+Solution #42:+  q1 :: Bool -> Bool+  q1 True = False+  q1 _    = True ++  q2 :: Bool -> Bool -> Bool+  q2 False False = True +  q2 _     _     = False+Solution #43:+  q1 :: Bool -> Bool+  q1 _ = False++  q2 :: Bool -> Bool -> Bool+  q2 True False = False+  q2 True True  = False+  q2 _    _     = True +Solution #44:+  q1 :: Bool -> Bool+  q1 True = True +  q1 _    = False++  q2 :: Bool -> Bool -> Bool+  q2 _ _ = True+Solution #45:+  q1 :: Bool -> Bool+  q1 _ = False++  q2 :: Bool -> Bool -> Bool+  q2 True True = False+  q2 _    _    = True +Solution #46:+  q1 :: Bool -> Bool+  q1 True = True +  q1 _    = False++  q2 :: Bool -> Bool -> Bool+  q2 True True = False+  q2 _    _    = True +Solution #47:+  q1 :: Bool -> Bool+  q1 True = True +  q1 _    = False++  q2 :: Bool -> Bool -> Bool+  q2 True False = False+  q2 True True  = False+  q2 _    _     = True +Solution #48:+  q1 :: Bool -> Bool+  q1 _ = False++  q2 :: Bool -> Bool -> Bool+  q2 True  True = False+  q2 False True = False+  q2 _     _    = True +Solution #49:+  q1 :: Bool -> Bool+  q1 True = True +  q1 _    = False++  q2 :: Bool -> Bool -> Bool+  q2 True  False = True +  q2 False False = True +  q2 _     _     = False+Solution #50:+  q1 :: Bool -> Bool+  q1 True = True +  q1 _    = False++  q2 :: Bool -> Bool -> Bool+  q2 False False = True +  q2 _     _     = False+Solution #51:+  q1 :: Bool -> Bool+  q1 _ = True++  q2 :: Bool -> Bool -> Bool+  q2 False True = False+  q2 _     _    = True +Solution #52:+  q1 :: Bool -> Bool+  q1 False = True +  q1 _     = False++  q2 :: Bool -> Bool -> Bool+  q2 False True = False+  q2 _     _    = True +Solution #53:+  q1 :: Bool -> Bool+  q1 True = True +  q1 _    = False++  q2 :: Bool -> Bool -> Bool+  q2 False True = False+  q2 _     _    = True +Solution #54:+  q1 :: Bool -> Bool+  q1 _ = False++  q2 :: Bool -> Bool -> Bool+  q2 False True = False+  q2 _     _    = True +Solution #55:+  q1 :: Bool -> Bool+  q1 _ = True++  q2 :: Bool -> Bool -> Bool+  q2 True  True  = True +  q2 False False = True +  q2 _     _     = False+Solution #56:+  q1 :: Bool -> Bool+  q1 True = False+  q1 _    = True ++  q2 :: Bool -> Bool -> Bool+  q2 True  True  = True +  q2 False False = True +  q2 _     _     = False Solution #57:   q1 :: Bool -> Bool   q1 True = True
SBVTestSuite/GoldFiles/validate_1.gold view
@@ -29,11 +29,11 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (s0))-[RECV] ((s0 (fp #b1 #xfe #b11111111111111111111111)))+[RECV] ((s0 (_ -zero 8 24))) *** Solver   : Z3 *** Exit code: ExitSuccess [VALIDATE] Validating the model. Assignment:-[VALIDATE]       x = -3.4028235e38 :: Float+[VALIDATE]       x = -0.0 :: Float [VALIDATE] There are no constraints to check. [VALIDATE] Validating outputs. @@ -42,7 +42,7 @@ ***  *** Assignment: *** -***       x = -3.4028235e38 :: Float+***       x = -0.0 :: Float ***  *** Not all floating point operations are supported concretely. *** @@ -52,4 +52,4 @@ *** Alleged model: *** *** Satisfiable. Model:-***   x = -3.4028235e38 :: Float+***   x = -0.0 :: Float
SBVTestSuite/GoldFiles/validate_2.gold view
@@ -29,11 +29,11 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (s0))-[RECV] ((s0 (_ -zero 8 24)))+[RECV] ((s0 (_ +zero 8 24))) *** Solver   : Z3 *** Exit code: ExitSuccess [VALIDATE] Validating the model. Assignment:-[VALIDATE]       x = -0.0 :: Float+[VALIDATE]       x = 0.0 :: Float [VALIDATE] There are no constraints to check. [VALIDATE] Validating outputs. @@ -42,7 +42,7 @@ ***  *** Assignment: *** -***       x = -0.0 :: Float+***       x = 0.0 :: Float ***  *** Floating point FMA operation is not supported concretely. *** @@ -52,4 +52,4 @@ *** Alleged model: *** *** Satisfiable. Model:-***   x = -0.0 :: Float+***   x = 0.0 :: Float
SBVTestSuite/GoldFiles/validate_7.gold view
@@ -5,7 +5,7 @@ [GOOD] (set-option :smtlib2_compliant true) [GOOD] (set-option :diagnostic-output-channel "stdout") [GOOD] (set-option :produce-models true)-[GOOD] (set-logic ALL)+[GOOD] (set-logic ALL) ; has quantified booleans, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums ---
SBVTestSuite/SBVConnectionTest.hs view
@@ -4,7 +4,7 @@  module Main (main) where -import Data.SBV+import Data.SBV hiding (partition) import Data.List import Control.Monad import System.Exit@@ -18,7 +18,7 @@ solverName = show . name . solver  main :: IO ()-main = do let allSolvers = map (\s -> (solverName s, s)) [abc, boolector, bitwuzla, cvc4, cvc5, mathSAT, yices, z3, dReal]+main = do let allSolvers = map (\s -> (solverName s, s)) [abc, boolector, bitwuzla, cvc4, cvc5, mathSAT, yices, z3, dReal, openSMT]            args <- getArgs @@ -33,8 +33,9 @@               (requiredBad, requiredPresent) = partition (\(n, _) -> n `elem` map solverName badSolvers) chosenSolvers                pickTest s = case name (solver s) of-                             DReal -> testI s-                             _     -> test  s+                             DReal   -> testI s+                             OpenSMT -> testO s+                             _       -> test  s            mapM_ (pickTest . snd) requiredPresent @@ -61,12 +62,19 @@         t3 x = x*x .== (3::SWord8)         t4 x = x*3 .== (12::SWord8) --- integer only test, for dReal mostly+-- for dreal testI :: SMTConfig -> IO () testI s = do check s "t0" t0 id              check s "t1" t1 not   where t0 x = x .== (x :: SReal)         t1 x = x .== (2 :: SReal) .&& (x .== 3)++-- for openSMT+testO :: SMTConfig -> IO ()+testO s = do check s "t0" t0 id+             check s "t1" t1 not+  where t0 = do {setLogic QF_RDL; x <- free "x"; pure (x .== (x :: SReal))}+        t1 = do {setLogic QF_RDL; x <- free "x"; pure (x .== (2 :: SReal) .&& (x .== 3))}  check :: Provable a => SMTConfig -> String -> a -> (Bool -> Bool) -> IO () check s m p f = isTheoremWith s p >>= decide s m f
SBVTestSuite/SBVTest.hs view
@@ -75,7 +75,6 @@ import qualified TestSuite.Crypto.AES import qualified TestSuite.Crypto.RC4 import qualified TestSuite.Crypto.SHA-import qualified TestSuite.Existentials.CRCPolynomial import qualified TestSuite.GenTest.GenTests import qualified TestSuite.Optimization.AssertWithPenalty import qualified TestSuite.Optimization.Basics@@ -189,7 +188,6 @@                       , 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
SBVTestSuite/TestSuite/Basics/ArithNoSolver.hs view
@@ -10,11 +10,16 @@ -- the constant folding based arithmetic implementation in SBV ----------------------------------------------------------------------------- -{-# LANGUAGE FlexibleContexts    #-}-{-# LANGUAGE Rank2Types          #-}-{-# LANGUAGE TupleSections       #-}+{-# LANGUAGE CPP              #-}+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE Rank2Types       #-}+{-# LANGUAGE TupleSections    #-} -{-# OPTIONS_GHC -Wall -Werror #-}+#if MIN_VERSION_base(4,19,0)+{-# OPTIONS_GHC -Wall -Werror -Wno-incomplete-uni-patterns -Wno-x-partial #-}+#else+{-# OPTIONS_GHC -Wall -Werror -Wno-incomplete-uni-patterns #-}+#endif  module TestSuite.Basics.ArithNoSolver(tests) where
SBVTestSuite/TestSuite/Basics/ArithSolver.hs view
@@ -11,12 +11,17 @@ -- constant folding. ----------------------------------------------------------------------------- +{-# LANGUAGE CPP                 #-} {-# LANGUAGE FlexibleContexts    #-} {-# LANGUAGE Rank2Types          #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE DataKinds           #-} -{-# OPTIONS_GHC -Wall -Werror #-}+#if MIN_VERSION_base(4,19,0)+{-# OPTIONS_GHC -Wall -Werror -Wno-incomplete-uni-patterns -Wno-x-partial #-}+#else+{-# OPTIONS_GHC -Wall -Werror -Wno-incomplete-uni-patterns #-}+#endif  module TestSuite.Basics.ArithSolver(tests) where
SBVTestSuite/TestSuite/Basics/BasicTests.hs view
@@ -16,9 +16,17 @@  module TestSuite.Basics.BasicTests(tests) where -import Data.SBV.Internals hiding (free, output)+import Data.SBV.Control+import Data.SBV.Internals hiding (free, output, newArray_) import Utils.SBVTestFramework +import Control.Monad       (void)+import Control.Monad.Trans (liftIO)++import System.Random++import qualified Control.Exception as C+ -- Test suite tests :: TestTree tests = testGroup "Basics.BasicTests"@@ -52,6 +60,10 @@    , goldenVsStringShow "basic-5_3" $ test5 f3    , goldenVsStringShow "basic-5_4" $ test5 f4    , goldenVsStringShow "basic-5_5" $ test5 f5+   , goldenCapturedIO   "nested1"   $ nested nested1+   , goldenCapturedIO   "nested2"   $ nested nested2+   , goldenCapturedIO   "nested3"   $ nested nested3+   , goldenCapturedIO   "nested4"   $ nested nested4    ]  test0 :: (forall a. Num a => (a -> a -> a)) -> Word8@@ -81,3 +93,47 @@ f3 x y = (x+y)*(x+y) f4 x y = let z = x + y in z * z f5 x _ = x + 1++-- Nested calls are not OK; make sure we catch these+nested :: (SMTConfig -> IO a) -> FilePath -> IO ()+nested t rf = do setStdGen (mkStdGen 0)+                 void (t z3{verbose=True, redirectVerbose=Just rf})+                  `C.catch` \(e::C.SomeException) -> do appendFile rf "CAUGHT EXCEPTION\n\n"+                                                        appendFile rf (show e)++nested1 :: SMTConfig -> IO ThmResult+nested1 cfg = proveWith cfg $ do+  x <- free "x"+  y <- free "y"+  liftIO $ f x y+ where f :: SWord32 -> SWord32 -> IO SBool+       f x y = do+         res <- isSatisfiable $ x .== y+         return $ if res then sTrue else sFalse++nested2 :: SMTConfig -> IO ThmResult+nested2 cfg = proveWith cfg $ do+  x <- free "x"+  liftIO $ f x+ where f :: SWord32 -> IO SBool+       f x = do+         res <- isSatisfiable $ x .== 2+         return $ if res then sTrue else sFalse++nested3 :: SMTConfig -> IO ThmResult+nested3 cfg = proveWith cfg $ do+        y <- sBool "y"+        x <- liftIO leak        -- reach in!+        return $ y .== x+  where leak :: IO SBool+        leak = runSMTWith cfg $ do+                        x <- sBool "x"+                        query $ pure x++nested4 :: SMTConfig -> IO Bool+nested4 cfg = do+  d1 <- runSMT (newArray_ Nothing :: Symbolic (SArray Bool Bool))++  let sboolOfInterest = readArray d1 sTrue++  isSatisfiableWith cfg sboolOfInterest
SBVTestSuite/TestSuite/Basics/GenBenchmark.hs view
@@ -24,4 +24,4 @@     ]     where gen generator f =                 -- the first line is time-stamp, get rid of it so test is repeatable-                unlines . tail . lines <$> generator f+                unlines . drop 1 . lines <$> generator f
SBVTestSuite/TestSuite/Basics/IteTest.hs view
@@ -19,7 +19,9 @@ chk1 cond x = cond (x .== x) sTrue undefined  chk2 :: (SBool -> [SBool] -> [SBool] -> [SBool]) -> SWord8 -> SBool-chk2 cond x = head (cond (x .== x) [sTrue] [undefined])+chk2 cond x = case cond (x .== x) [sTrue] [undefined] of+                [v] -> v+                _   -> error "chk2: Impossible happened in call to cond!"  chk3 :: (SBool -> (SBool, SBool) -> (SBool, SBool)  -> (SBool, SBool)) -> SWord8 -> SBool chk3 cond x = fst (cond (x .== x) (sTrue, undefined::SBool) (undefined, undefined))
SBVTestSuite/TestSuite/Basics/Lambda.hs view
@@ -131,13 +131,13 @@       , goldenCapturedIO "lambda37" $ record $ \st -> constraintStr st $ \(Forall b)             -> sNot b       , goldenCapturedIO "lambda38" $ record $ \st -> constraintStr st $ \(Forall x) (Forall y) -> x .== (0 :: SInteger) .|| y -      , goldenCapturedIO "lambda40" $ record $ \st -> namedLambdaStr st "lambda40" (kindOf (Proxy @SInteger)) (0           :: SInteger)-      , goldenCapturedIO "lambda41" $ record $ \st -> namedLambdaStr st "lambda41" (kindOf (Proxy @SInteger)) (\x   -> x+1 :: SInteger)-      , goldenCapturedIO "lambda42" $ record $ \st -> namedLambdaStr st "lambda42" (kindOf (Proxy @SInteger)) (\x y -> x+y :: SInteger)+      , goldenCapturedIO "lambda40" $ record $ \st -> namedLambdaStr st "lambda40" t_i    (0           :: SInteger)+      , goldenCapturedIO "lambda41" $ record $ \st -> namedLambdaStr st "lambda41" t_i2i  (\x   -> x+1 :: SInteger)+      , goldenCapturedIO "lambda42" $ record $ \st -> namedLambdaStr st "lambda42" t_ii2i (\x y -> x+y :: SInteger) -      , goldenCapturedIO "lambda43" $ record $ \st -> namedLambdaStr st "lambda43" (kindOf (Proxy @SWord32)) (0           :: SWord32)-      , goldenCapturedIO "lambda44" $ record $ \st -> namedLambdaStr st "lambda44" (kindOf (Proxy @SWord32)) (\x   -> x+1 :: SWord32)-      , goldenCapturedIO "lambda45" $ record $ \st -> namedLambdaStr st "lambda45" (kindOf (Proxy @SWord32)) (\x y -> x+y :: SWord32)+      , goldenCapturedIO "lambda43" $ record $ \st -> namedLambdaStr st "lambda43" t_w32         (0           :: SWord32)+      , goldenCapturedIO "lambda44" $ record $ \st -> namedLambdaStr st "lambda44" t_w32_w32     (\x   -> x+1 :: SWord32)+      , goldenCapturedIO "lambda45" $ record $ \st -> namedLambdaStr st "lambda45" t_w32_w32_w32 (\x y -> x+y :: SWord32)        , goldenCapturedIO "lambda46" $ runSat ((.== 5) . add1) @@ -218,12 +218,41 @@                     snPhi :: Forall "x" Integer -> SBool                     snPhi = skolemize nPhi                 in runS snPhi++      , goldenCapturedIO "lambda71" $ \f -> sbv2smt def_foo >>= writeFile f+      , goldenCapturedIO "lambda72" $ \f -> sbv2smt def_bar >>= writeFile f+      , goldenCapturedIO "lambda73" $ \f -> sbv2smt def_baz >>= writeFile f+      , goldenCapturedIO "lambda74" $ \f -> sbv2smt def_e   >>= writeFile f+      , goldenCapturedIO "lambda75" $ \f -> sbv2smt def_o   >>= writeFile f++      , goldenCapturedIO "lambda76" $ \f -> sbv2smt (2 :: SInteger)                    >>= writeFile f+      , goldenCapturedIO "lambda77" $ \f -> sbv2smt (literal 'a' :: SChar)             >>= writeFile f+      , goldenCapturedIO "lambda78" $ \f -> sbv2smt (literal [1,2,3] :: SList Integer) >>= writeFile f++      , goldenCapturedIO "lambda79" $ \f -> sbv2smt def_t1 >>= writeFile f+      , goldenCapturedIO "lambda80" $ \f -> sbv2smt def_t2 >>= writeFile f       ]    P.++ qc1 "lambdaQC1" P.sum (foldr (+) (0::SInteger))    P.++ qc2 "lambdaQC2" (+)  (smtFunction "sadd" ((+) :: SInteger -> SInteger -> SInteger))    P.++ qc1 "lambdaQC3" (\n -> let pn = abs n in (pn * (pn+1)) `sDiv` 2)                         (let ssum = smtFunction "ssum" $ \(n :: SInteger) -> let pn = abs n in ite (pn .== 0) 0 (pn + ssum (pn - 1)) in ssum)-  where rel, leq :: Relation Integer+  where t_i           = SBVType [kindOf (Proxy @SInteger)]+        t_i2i         = SBVType [kindOf (Proxy @SInteger), kindOf (Proxy @SInteger)]+        t_ii2i        = SBVType [kindOf (Proxy @SInteger), kindOf (Proxy @SInteger), kindOf (Proxy @SInteger)]+        t_w32         = SBVType [kindOf (Proxy @SWord32)]+        t_w32_w32     = SBVType [kindOf (Proxy @SWord32), kindOf (Proxy @SWord32)]+        t_w32_w32_w32 = SBVType [kindOf (Proxy @SWord32), kindOf (Proxy @SWord32), kindOf (Proxy @SWord32)]++        def_foo, def_bar, def_baz, def_e, def_o :: SInteger -> SInteger+        def_foo = smtFunction "foo" $ \x -> def_bar (x-1)+        def_bar = smtFunction "bar" $ \x -> def_bar (x-1)+        def_baz = smtFunction "baz" $ \x -> x+1+        def_e = smtFunction "e" $ \x -> def_o (x-1)+        def_o = smtFunction "o" $ \x -> def_e (x-1)+        def_t1 = smtFunction "foo" (\x -> select [1,2,3]       (0 :: SWord32)  (x::SInteger))+        def_t2 = smtFunction "foo" (\x -> select [x+1,x+2,x+3] (0 :: SInteger) (x::SInteger))++        rel, leq :: Relation Integer         rel = uninterpret "R"         leq = uncurry $ smtFunction "leq" (.<=)         po  = isPartialOrder "poR" rel
SBVTestSuite/TestSuite/Basics/Quantifiers.hs view
@@ -9,10 +9,15 @@ -- Various combinations of quantifiers ----------------------------------------------------------------------------- +{-# LANGUAGE CPP                 #-} {-# LANGUAGE DataKinds           #-} {-# LANGUAGE FlexibleContexts    #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TypeApplications    #-}++#if MIN_VERSION_base(4,19,0)+{-# LANGUAGE TypeAbstractions    #-}+#endif  {-# OPTIONS_GHC -Wall -Werror #-}
− SBVTestSuite/TestSuite/Existentials/CRCPolynomial.hs 
@@ -1,29 +0,0 @@--------------------------------------------------------------------------------- |--- Module    : TestSuite.Existentials.CRCPolynomial--- Copyright : (c) Levent Erkok--- License   : BSD3--- Maintainer: erkokl@gmail.com--- Stability : experimental------ Test suite for Documentation.SBV.Examples.Existentials.CRCPolynomial--------------------------------------------------------------------------------{-# OPTIONS_GHC -Wall -Werror #-}--module TestSuite.Existentials.CRCPolynomial(tests) where--import Documentation.SBV.Examples.Existentials.CRCPolynomial--import Utils.SBVTestFramework---- Test suite-tests :: TestTree-tests = testGroup "Existentials.CRCPolynomial" [-    goldenVsStringShow "crcPolyExist" (runSAT pgm)-  , testCase           "crcPolyGood"  (assertIsSat pgm)- ]--pgm :: Predicate-pgm = do poly <- free "poly"-         pure $ quantifiedBool $ \(Forall sent) (Forall received) -> sTestBit poly 0 .&& crcGood 4 poly sent received
SBVTestSuite/TestSuite/Overflows/Arithmetic.hs view
@@ -27,101 +27,61 @@ -- Test suite tests :: TestTree tests = testGroup "Overflows" [testGroup "Arithmetic" ts]-  where ts = [ testGroup "add-uf" [ testCase "w8"  $ assertIsThm $ underflow  svPlus     (bvAddO :: SWord8  -> SWord8  -> (SBool, SBool))-                                  , testCase "w16" $ assertIsThm $ underflow  svPlus     (bvAddO :: SWord16 -> SWord16 -> (SBool, SBool))-                                  , testCase "w32" $ assertIsThm $ underflow  svPlus     (bvAddO :: SWord32 -> SWord32 -> (SBool, SBool))-                                  , testCase "w64" $ assertIsThm $ underflow  svPlus     (bvAddO :: SWord64 -> SWord64 -> (SBool, SBool))-                                  , testCase "i8"  $ assertIsThm $ underflow  svPlus     (bvAddO :: SInt8   -> SInt8   -> (SBool, SBool))-                                  , testCase "i16" $ assertIsThm $ underflow  svPlus     (bvAddO :: SInt16  -> SInt16  -> (SBool, SBool))-                                  , testCase "i32" $ assertIsThm $ underflow  svPlus     (bvAddO :: SInt32  -> SInt32  -> (SBool, SBool))-                                  , testCase "i64" $ assertIsThm $ underflow  svPlus     (bvAddO :: SInt64  -> SInt64  -> (SBool, SBool))-                                  ]-             , testGroup "add-of" [ testCase "w8"  $ assertIsThm $ overflow   svPlus     (bvAddO :: SWord8  -> SWord8  -> (SBool, SBool))-                                  , testCase "w16" $ assertIsThm $ overflow   svPlus     (bvAddO :: SWord16 -> SWord16 -> (SBool, SBool))-                                  , testCase "w32" $ assertIsThm $ overflow   svPlus     (bvAddO :: SWord32 -> SWord32 -> (SBool, SBool))-                                  , testCase "w64" $ assertIsThm $ overflow   svPlus     (bvAddO :: SWord64 -> SWord64 -> (SBool, SBool))-                                  , testCase "i8"  $ assertIsThm $ overflow   svPlus     (bvAddO :: SInt8   -> SInt8   -> (SBool, SBool))-                                  , testCase "i16" $ assertIsThm $ overflow   svPlus     (bvAddO :: SInt16  -> SInt16  -> (SBool, SBool))-                                  , testCase "i32" $ assertIsThm $ overflow   svPlus     (bvAddO :: SInt32  -> SInt32  -> (SBool, SBool))-                                  , testCase "i64" $ assertIsThm $ overflow   svPlus     (bvAddO :: SInt64  -> SInt64  -> (SBool, SBool))-                                  ]-             , testGroup "sub-uf" [ testCase "w8"  $ assertIsThm $ underflow  svMinus    (bvSubO :: SWord8  -> SWord8  -> (SBool, SBool))-                                  , testCase "w16" $ assertIsThm $ underflow  svMinus    (bvSubO :: SWord16 -> SWord16 -> (SBool, SBool))-                                  , testCase "w32" $ assertIsThm $ underflow  svMinus    (bvSubO :: SWord32 -> SWord32 -> (SBool, SBool))-                                  , testCase "w64" $ assertIsThm $ underflow  svMinus    (bvSubO :: SWord64 -> SWord64 -> (SBool, SBool))-                                  , testCase "i8"  $ assertIsThm $ underflow  svMinus    (bvSubO :: SInt8   -> SInt8   -> (SBool, SBool))-                                  , testCase "i16" $ assertIsThm $ underflow  svMinus    (bvSubO :: SInt16  -> SInt16  -> (SBool, SBool))-                                  , testCase "i32" $ assertIsThm $ underflow  svMinus    (bvSubO :: SInt32  -> SInt32  -> (SBool, SBool))-                                  , testCase "i64" $ assertIsThm $ underflow  svMinus    (bvSubO :: SInt64  -> SInt64  -> (SBool, SBool))-                                  ]-             , testGroup "sub-of" [ testCase "w8"  $ assertIsThm $ overflow   svMinus    (bvSubO :: SWord8  -> SWord8  -> (SBool, SBool))-                                  , testCase "w16" $ assertIsThm $ overflow   svMinus    (bvSubO :: SWord16 -> SWord16 -> (SBool, SBool))-                                  , testCase "w32" $ assertIsThm $ overflow   svMinus    (bvSubO :: SWord32 -> SWord32 -> (SBool, SBool))-                                  , testCase "w64" $ assertIsThm $ overflow   svMinus    (bvSubO :: SWord64 -> SWord64 -> (SBool, SBool))-                                  , testCase "i8"  $ assertIsThm $ overflow   svMinus    (bvSubO :: SInt8   -> SInt8   -> (SBool, SBool))-                                  , testCase "i16" $ assertIsThm $ overflow   svMinus    (bvSubO :: SInt16  -> SInt16  -> (SBool, SBool))-                                  , testCase "i32" $ assertIsThm $ overflow   svMinus    (bvSubO :: SInt32  -> SInt32  -> (SBool, SBool))-                                  , testCase "i64" $ assertIsThm $ overflow   svMinus    (bvSubO :: SInt64  -> SInt64  -> (SBool, SBool))-                                  ]-             , testGroup "mul-uf" [ testCase "w8"  $ assertIsThm $ underflow  svTimes    (bvMulO :: SWord8  -> SWord8  -> (SBool, SBool))-                                  , testCase "w16" $ assertIsThm $ underflow  svTimes    (bvMulO :: SWord16 -> SWord16 -> (SBool, SBool))-                                  , testCase "w32" $ assertIsThm $ underflow  svTimes    (bvMulO :: SWord32 -> SWord32 -> (SBool, SBool))-                                  , testCase "w64" $ assertIsThm $ underflow  svTimes    (bvMulO :: SWord64 -> SWord64 -> (SBool, SBool))-                                  , testCase "i8"  $ assertIsThm $ mulChkU    bvMulOFast (bvMulO :: SInt8   -> SInt8   -> (SBool, SBool))-                                  , testCase "i16" $ assertIsThm $ mulChkU    bvMulOFast (bvMulO :: SInt16  -> SInt16  -> (SBool, SBool))-                                  , testCase "i32" $ assertIsThm $ mulChkU    bvMulOFast (bvMulO :: SInt32  -> SInt32  -> (SBool, SBool))-                                  , testCase "i64" $ assertIsThm $ mulChkU    bvMulOFast (bvMulO :: SInt64  -> SInt64  -> (SBool, SBool))-                                  ]-             , testGroup "mul-of" [ testCase "w8"  $ assertIsThm $ mulChkO    bvMulOFast (bvMulO :: SWord8  -> SWord8  -> (SBool, SBool))-                                  , testCase "w16" $ assertIsThm $ mulChkO    bvMulOFast (bvMulO :: SWord16 -> SWord16 -> (SBool, SBool))-                                  , testCase "w32" $ assertIsThm $ mulChkO    bvMulOFast (bvMulO :: SWord32 -> SWord32 -> (SBool, SBool))-                                  , testCase "w64" $ assertIsThm $ mulChkO    bvMulOFast (bvMulO :: SWord64 -> SWord64 -> (SBool, SBool))-                                  , testCase "i8"  $ assertIsThm $ mulChkO    bvMulOFast (bvMulO :: SInt8   -> SInt8   -> (SBool, SBool))-                                  , testCase "i16" $ assertIsThm $ mulChkO    bvMulOFast (bvMulO :: SInt16  -> SInt16  -> (SBool, SBool))-                                  , testCase "i32" $ assertIsThm $ mulChkO    bvMulOFast (bvMulO :: SInt32  -> SInt32  -> (SBool, SBool))-                                  , testCase "i64" $ assertIsThm $ mulChkO    bvMulOFast (bvMulO :: SInt64  -> SInt64  -> (SBool, SBool))+  where ts = [ testGroup "add-ov" [ testCase "w8"  $ assertIsThm $ overflow  svPlus   (bvAddO :: SWord8  -> SWord8  -> SBool)+                                  , testCase "w16" $ assertIsThm $ overflow  svPlus   (bvAddO :: SWord16 -> SWord16 -> SBool)+                                  , testCase "w32" $ assertIsThm $ overflow  svPlus   (bvAddO :: SWord32 -> SWord32 -> SBool)+                                  , testCase "w64" $ assertIsThm $ overflow  svPlus   (bvAddO :: SWord64 -> SWord64 -> SBool)+                                  , testCase "i8"  $ assertIsThm $ overflow  svPlus   (bvAddO :: SInt8   -> SInt8   -> SBool)+                                  , testCase "i16" $ assertIsThm $ overflow  svPlus   (bvAddO :: SInt16  -> SInt16  -> SBool)+                                  , testCase "i32" $ assertIsThm $ overflow  svPlus   (bvAddO :: SInt32  -> SInt32  -> SBool)+                                  , testCase "i64" $ assertIsThm $ overflow  svPlus   (bvAddO :: SInt64  -> SInt64  -> SBool)                                   ]-             , testGroup "div-uf" [ testCase "w8"  $ assertIsThm $ never      svDivide    (bvDivO :: SWord8  -> SWord8  -> (SBool, SBool))-                                  , testCase "w16" $ assertIsThm $ never      svDivide    (bvDivO :: SWord16 -> SWord16 -> (SBool, SBool))-                                  , testCase "w32" $ assertIsThm $ never      svDivide    (bvDivO :: SWord32 -> SWord32 -> (SBool, SBool))-                                  , testCase "w64" $ assertIsThm $ never      svDivide    (bvDivO :: SWord64 -> SWord64 -> (SBool, SBool))-                                  , testCase "i8"  $ assertIsThm $ never      svDivide    (bvDivO :: SInt8   -> SInt8   -> (SBool, SBool))-                                  , testCase "i16" $ assertIsThm $ never      svDivide    (bvDivO :: SInt16  -> SInt16  -> (SBool, SBool))-                                  , testCase "i32" $ assertIsThm $ never      svDivide    (bvDivO :: SInt32  -> SInt32  -> (SBool, SBool))-                                  , testCase "i64" $ assertIsThm $ never      svDivide    (bvDivO :: SInt64  -> SInt64  -> (SBool, SBool))++             , testGroup "sub-ov" [ testCase "w8"  $ assertIsThm $ overflow  svMinus  (bvSubO :: SWord8  -> SWord8  -> SBool)+                                  , testCase "w16" $ assertIsThm $ overflow  svMinus  (bvSubO :: SWord16 -> SWord16 -> SBool)+                                  , testCase "w32" $ assertIsThm $ overflow  svMinus  (bvSubO :: SWord32 -> SWord32 -> SBool)+                                  , testCase "w64" $ assertIsThm $ overflow  svMinus  (bvSubO :: SWord64 -> SWord64 -> SBool)+                                  , testCase "i8"  $ assertIsThm $ overflow  svMinus  (bvSubO :: SInt8   -> SInt8   -> SBool)+                                  , testCase "i16" $ assertIsThm $ overflow  svMinus  (bvSubO :: SInt16  -> SInt16  -> SBool)+                                  , testCase "i32" $ assertIsThm $ overflow  svMinus  (bvSubO :: SInt32  -> SInt32  -> SBool)+                                  , testCase "i64" $ assertIsThm $ overflow  svMinus  (bvSubO :: SInt64  -> SInt64  -> SBool)                                   ]-             , testGroup "div-of" [ testCase "w8"  $ assertIsThm $ never      svDivide    (bvDivO :: SWord8  -> SWord8  -> (SBool, SBool))-                                  , testCase "w16" $ assertIsThm $ never      svDivide    (bvDivO :: SWord16 -> SWord16 -> (SBool, SBool))-                                  , testCase "w32" $ assertIsThm $ never      svDivide    (bvDivO :: SWord32 -> SWord32 -> (SBool, SBool))-                                  , testCase "w64" $ assertIsThm $ never      svDivide    (bvDivO :: SWord64 -> SWord64 -> (SBool, SBool))-                                  , testCase "i8"  $ assertIsThm $ divChk     svDivide    (bvDivO :: SInt8   -> SInt8   -> (SBool, SBool))-                                  , testCase "i16" $ assertIsThm $ divChk     svDivide    (bvDivO :: SInt16  -> SInt16  -> (SBool, SBool))-                                  , testCase "i32" $ assertIsThm $ divChk     svDivide    (bvDivO :: SInt32  -> SInt32  -> (SBool, SBool))-                                  , testCase "i64" $ assertIsThm $ divChk     svDivide    (bvDivO :: SInt64  -> SInt64  -> (SBool, SBool))++             -- Multiplication checks are expensive; so only do at a few instances+             , testGroup "mul-ov" [ testCase "w8"  $ assertIsThm $ overflow  svTimes  (bvMulO :: SWord8  -> SWord8  -> SBool)+                                  , testCase "w16" $ assertIsThm $ overflow  svTimes  (bvMulO :: SWord16 -> SWord16 -> SBool)+                                  -- , testCase "w32" $ assertIsThm $ overflow  svTimes  (bvMulO :: SWord32 -> SWord32 -> SBool)+                                  -- , testCase "w64" $ assertIsThm $ overflow  svTimes  (bvMulO :: SWord64 -> SWord64 -> SBool)+                                  , testCase "i8"  $ assertIsThm $ overflow  svTimes  (bvMulO :: SInt8   -> SInt8   -> SBool)+                                  -- , testCase "i16" $ assertIsThm $ overflow  svTimes  (bvMulO :: SInt16  -> SInt16  -> SBool)+                                  -- , testCase "i32" $ assertIsThm $ overflow  svTimes  (bvMulO :: SInt32  -> SInt32  -> SBool)+                                  -- , testCase "i64" $ assertIsThm $ overflow  svTimes  (bvMulO :: SInt64  -> SInt64  -> SBool)                                   ]-             , testGroup "neg-uf" [ testCase "w8"  $ assertIsThm $ never1     svNeg0      (bvNegO :: SWord8  -> (SBool, SBool))-                                  , testCase "w16" $ assertIsThm $ never1     svNeg0      (bvNegO :: SWord16 -> (SBool, SBool))-                                  , testCase "w32" $ assertIsThm $ never1     svNeg0      (bvNegO :: SWord32 -> (SBool, SBool))-                                  , testCase "w64" $ assertIsThm $ never1     svNeg0      (bvNegO :: SWord64 -> (SBool, SBool))-                                  , testCase "i8"  $ assertIsThm $ underflow1 svNeg0      (bvNegO :: SInt8   -> (SBool, SBool))-                                  , testCase "i16" $ assertIsThm $ underflow1 svNeg0      (bvNegO :: SInt16  -> (SBool, SBool))-                                  , testCase "i32" $ assertIsThm $ underflow1 svNeg0      (bvNegO :: SInt32  -> (SBool, SBool))-                                  , testCase "i64" $ assertIsThm $ underflow1 svNeg0      (bvNegO :: SInt64  -> (SBool, SBool))++             , testGroup "div-ov" [ testCase "w8"  $ assertIsThm $ never     svDivide (bvDivO :: SWord8  -> SWord8  -> SBool)+                                  , testCase "w16" $ assertIsThm $ never     svDivide (bvDivO :: SWord16 -> SWord16 -> SBool)+                                  , testCase "w32" $ assertIsThm $ never     svDivide (bvDivO :: SWord32 -> SWord32 -> SBool)+                                  , testCase "w64" $ assertIsThm $ never     svDivide (bvDivO :: SWord64 -> SWord64 -> SBool)+                                  , testCase "i8"  $ assertIsThm $ overflow  svDivide (bvDivO :: SInt8   -> SInt8   -> SBool)+                                  , testCase "i16" $ assertIsThm $ overflow  svDivide (bvDivO :: SInt16  -> SInt16  -> SBool)+                                  , testCase "i32" $ assertIsThm $ overflow  svDivide (bvDivO :: SInt32  -> SInt32  -> SBool)+                                  , testCase "i64" $ assertIsThm $ overflow  svDivide (bvDivO :: SInt64  -> SInt64  -> SBool)                                   ]-             , testGroup "neg-of" [ testCase "w8"  $ assertIsThm $ never1     svNeg0      (bvNegO :: SWord8  -> (SBool, SBool))-                                  , testCase "w16" $ assertIsThm $ never1     svNeg0      (bvNegO :: SWord16 -> (SBool, SBool))-                                  , testCase "w32" $ assertIsThm $ never1     svNeg0      (bvNegO :: SWord32 -> (SBool, SBool))-                                  , testCase "w64" $ assertIsThm $ never1     svNeg0      (bvNegO :: SWord64 -> (SBool, SBool))-                                  , testCase "i8"  $ assertIsThm $ overflow1  svNeg0      (bvNegO :: SInt8   -> (SBool, SBool))-                                  , testCase "i16" $ assertIsThm $ overflow1  svNeg0      (bvNegO :: SInt16  -> (SBool, SBool))-                                  , testCase "i32" $ assertIsThm $ overflow1  svNeg0      (bvNegO :: SInt32  -> (SBool, SBool))-                                  , testCase "i64" $ assertIsThm $ overflow1  svNeg0      (bvNegO :: SInt64  -> (SBool, SBool))++             , testGroup "neg-ov" [ testCase "w8"  $ assertIsThm $ never1    svNeg0   (bvNegO :: SWord8  -> SBool)+                                  , testCase "w16" $ assertIsThm $ never1    svNeg0   (bvNegO :: SWord16 -> SBool)+                                  , testCase "w32" $ assertIsThm $ never1    svNeg0   (bvNegO :: SWord32 -> SBool)+                                  , testCase "w64" $ assertIsThm $ never1    svNeg0   (bvNegO :: SWord64 -> SBool)+                                  , testCase "i8"  $ assertIsThm $ overflow1 svNeg0   (bvNegO :: SInt8   -> SBool)+                                  , testCase "i16" $ assertIsThm $ overflow1 svNeg0   (bvNegO :: SInt16  -> SBool)+                                  , testCase "i32" $ assertIsThm $ overflow1 svNeg0   (bvNegO :: SInt32  -> SBool)+                                  , testCase "i64" $ assertIsThm $ overflow1 svNeg0   (bvNegO :: SInt64  -> SBool)                                   ]              ] --- 256 bits is large enough to do all these proofs+-- 128 bits is large enough to do all these proofs large :: Int-large = 256+large = 128  type SLarge = SVal @@ -143,100 +103,45 @@          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-mulChkO fast slow = do setLogic Logic_NONE-                       x <- free "x"-                       y <- free "y"--                       let (_, ov1) = x `fast` y-                           (_, ov2) = x `slow` y--                       return $ ov1 .== ov2---- Underflow mults-mulChkU :: forall a. SymVal a => (SBV a -> SBV a -> (SBool, SBool)) -> (SBV a -> SBV a -> (SBool, SBool)) -> Predicate-mulChkU fast slow = do setLogic Logic_NONE-                       x <- free "x"-                       y <- free "y"--                       let (uf1, _) = x `fast` y-                           (uf2, _) = x `slow` y--                       return $ uf1 .== uf2---- Signed division can only underflow under one condition, check that simply instead of trying to do an expensive embedding proof-divChk :: forall a. (Integral a, Bounded a, SymVal a) => (SLarge -> SLarge -> SLarge) -> (SBV a -> SBV a -> (SBool, SBool)) -> Predicate-divChk _op cond = do x  <- free "x"-                     y  <- free "y"--                     let (_, overflowHappens) = x `cond` y--                         special = (unSBV x `svEqual` topSet) `svAnd` (unSBV y `svEqual` neg1)--                         n      = intSizeOf x-                         neg1   = svInteger (KBounded True n) (-1)-                         topSet = svInteger (KBounded True n) (2^(n-1))--                     return $ overflowHappens `exactlyWhen` special- -- For a few cases, we expect them to "never" overflow. The "embedding proofs" are either too expensive (in case of division), or -- not possible (in case of negation). We capture these here.-never :: forall a. (Integral a, Bounded a, SymVal a) => (SLarge -> SLarge -> SLarge) -> (SBV a -> SBV a -> (SBool, SBool)) -> Predicate+never :: forall a. (Integral a, Bounded a, SymVal a) => (SLarge -> SLarge -> SLarge) -> (SBV a -> SBV a -> SBool) -> Predicate never _op cond = do x  <- free "x"                     y  <- free "y" -                    let (underflowHappens, _) = x `cond` y+                    let overFlowHappens = x `cond` y -                    return $ underflowHappens `exactlyWhen` svFalse+                    return $ overFlowHappens `exactlyWhen` svFalse -never1 :: forall a. (Integral a, Bounded a, SymVal a) => (SLarge -> SLarge) -> (SBV a -> (SBool, SBool)) -> Predicate+never1 :: forall a. (Integral a, Bounded a, SymVal a) => (SLarge -> SLarge) -> (SBV a -> SBool) -> Predicate never1 _op cond = do x  <- free "x" -                     let (underflowHappens, _) = cond x--                     return $ underflowHappens `exactlyWhen` svFalse--underflow :: forall a. (Integral a, Bounded a, SymVal a) => (SLarge -> SLarge -> SLarge) -> (SBV a -> SBV a -> (SBool, SBool)) -> Predicate-underflow op cond = do x  <- free "x"-                       y  <- free "y"--                       let (underflowHappens, _) = x `cond` y--                           extResult :: SLarge-                           extResult = toLarge x `op` toLarge y+                     let overflowHappens = cond x -                       return $ underflowHappens `exactlyWhen` (extResult `svLessThan` toLarge (minBound :: SBV a))+                     return $ overflowHappens `exactlyWhen` svFalse -overflow :: forall a. (Integral a, Bounded a, SymVal a) => (SLarge -> SLarge -> SLarge) -> (SBV a -> SBV a -> (SBool, SBool)) -> Predicate+overflow :: forall a. (Integral a, Bounded a, SymVal a) => (SLarge -> SLarge -> SLarge) -> (SBV a -> SBV a -> SBool) -> Predicate overflow op cond = do x  <- free "x"                       y  <- free "y" -                      let (_, overflowHappens) = x `cond` y+                      let overflowHappens = x `cond` y                            extResult :: SLarge                           extResult = toLarge x `op` toLarge y -                      return $ overflowHappens `exactlyWhen` (extResult `svGreaterThan` toLarge (maxBound :: SBV a))--underflow1 :: forall a. (Integral a, Bounded a, SymVal a) => (SLarge -> SLarge) -> (SBV a -> (SBool, SBool)) -> Predicate-underflow1 op cond = do x  <- free "x"--                        let (underflowHappens, _) = cond x--                            extResult :: SLarge-                            extResult = op $ toLarge x--                        return $ underflowHappens `exactlyWhen` (extResult `svLessThan` toLarge (minBound :: SBV a))+                      return $ overflowHappens `exactlyWhen` (      (extResult `svGreaterThan` toLarge (maxBound :: SBV a))+                                                             `svOr` (extResult `svLessThan`    toLarge (minBound :: SBV a))+                                                             ) -overflow1 :: forall a. (Integral a, Bounded a, SymVal a) => (SLarge -> SLarge) -> (SBV a -> (SBool, SBool)) -> Predicate+overflow1 :: forall a. (Integral a, Bounded a, SymVal a) => (SLarge -> SLarge) -> (SBV a -> SBool) -> Predicate overflow1 op cond = do x  <- free "x" -                       let (_, overflowHappens) = cond x+                       let overflowHappens = cond x                             extResult :: SLarge                            extResult = op $ toLarge x -                       return $ overflowHappens `exactlyWhen` (extResult `svGreaterThan` toLarge (maxBound :: SBV a))+                       return $ overflowHappens `exactlyWhen` (       (extResult `svGreaterThan` toLarge (maxBound :: SBV a))+                                                               `svOr` (extResult `svLessThan`    toLarge (minBound :: SBV a)))  {- HLint ignore module "Reduce duplication" -}
SBVTestSuite/TestSuite/Puzzles/Coins.hs view
@@ -24,5 +24,5 @@  ]  where coinsPgm = runSAT $ do cs <- mapM mkCoin [1..6]                               mapM_ constrain [c s | s <- combinations cs, length s >= 2, c <- [c1, c2, c3, c4, c5, c6]]-                              constrain $ sAnd $ zipWith (.>=) cs (tail cs)+                              constrain $ sAnd $ zipWith (.>=) cs (drop 1 cs)                               pure $ sum cs .== 115
SBVTestSuite/TestSuite/Queries/UISatEx.hs view
@@ -9,11 +9,16 @@ -- Testing uninterpreted function extraction ----------------------------------------------------------------------------- +{-# LANGUAGE CPP                 #-} {-# LANGUAGE DataKinds           #-} {-# LANGUAGE OverloadedLists     #-} {-# LANGUAGE OverloadedStrings   #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TypeApplications    #-}++#if MIN_VERSION_base(4,19,0)+{-# LANGUAGE TypeAbstractions    #-}+#endif  {-# OPTIONS_GHC -Wall -Werror #-}
sbv.cabal view
@@ -1,7 +1,7 @@ Cabal-Version: 2.2  Name        : sbv-Version     : 10.2+Version     : 10.3 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-2023+Copyright          : Levent Erkok, 2010-2024 License            : BSD-3-Clause License-file       : LICENSE Stability          : Experimental@@ -19,9 +19,9 @@ Maintainer         : Levent Erkok (erkokl@gmail.com) Build-Type         : Simple Data-Files         : SBVTestSuite/GoldFiles/*.gold-Extra-Source-Files : INSTALL, README.md, COPYRIGHT, CHANGES.md+Extra-Doc-Files    : INSTALL, README.md, COPYRIGHT, CHANGES.md -Tested-With        : GHC==9.6.1+Tested-With        : GHC==9.8.1  source-repository head     type:       git@@ -29,8 +29,52 @@  common common-settings    default-language: Haskell2010-   ghc-options     : -Wall -O2+   ghc-options     : -Wall    build-depends   : base >= 4.16 && < 5+   other-extensions: BangPatterns+                     CPP+                     ConstrainedClassMethods+                     ConstraintKinds+                     DataKinds+                     DefaultSignatures+                     DeriveAnyClass+                     DeriveDataTypeable+                     DeriveFunctor+                     DeriveGeneric+                     DeriveTraversable+                     ExistentialQuantification+                     FlexibleContexts+                     FlexibleInstances+                     FunctionalDependencies+                     GADTs+                     GeneralizedNewtypeDeriving+                     ImplicitParams+                     InstanceSigs+                     KindSignatures+                     LambdaCase+                     MultiParamTypeClasses+                     NamedFieldPuns+                     NegativeLiterals+                     OverloadedLists+                     OverloadedRecordDot+                     OverloadedStrings+                     PackageImports+                     ParallelListComp+                     PatternGuards+                     QuantifiedConstraints+                     QuasiQuotes+                     Rank2Types+                     RankNTypes+                     RecordWildCards+                     ScopedTypeVariables+                     StandaloneDeriving+                     TemplateHaskell+                     TupleSections+                     TypeApplications+                     TypeFamilies+                     TypeOperators+                     UndecidableInstances+                     ViewPatterns     if impl(ghc >= 8.10.1)       ghc-options  : -Wunused-packages@@ -38,46 +82,24 @@ Library   import          : common-settings   default-language: Haskell2010-  other-extensions: BangPatterns-                    CPP-                    ConstraintKinds-                    DataKinds-                    DefaultSignatures-                    DeriveAnyClass-                    DeriveDataTypeable-                    DeriveFunctor-                    DeriveGeneric-                    FlexibleContexts-                    FlexibleInstances-                    FunctionalDependencies-                    GADTs-                    GeneralizedNewtypeDeriving-                    ImplicitParams-                    InstanceSigs-                    KindSignatures-                    LambdaCase-                    MultiParamTypeClasses-                    NamedFieldPuns-                    OverloadedLists-                    OverloadedStrings-                    PatternGuards-                    QuasiQuotes-                    Rank2Types-                    RankNTypes-                    ScopedTypeVariables-                    StandaloneDeriving-                    TemplateHaskell-                    TupleSections-                    TypeApplications-                    TypeFamilies-                    TypeOperators-                    TypeSynonymInstances-                    UndecidableInstances-                    ViewPatterns-  build-depends   : QuickCheck, template-haskell-                  , array, async, containers, deepseq, directory, filepath, time-                  , pretty, process, mtl, random, syb, text, transformers, uniplate-                  , libBF+  build-depends   : QuickCheck+                  , containers+                  , array+                  , deepseq+                  , template-haskell+                  , pretty+                  , random+                  , mtl+                  , transformers+                  , async+                  , filepath+                  , text+                  , directory+                  , time+                  , libBF            >= 0.6.7+                  , process+                  , syb+                  , uniplate   Exposed-modules : Data.SBV                   , Data.SBV.Control                   , Data.SBV.Dynamic@@ -110,7 +132,7 @@                   , Documentation.SBV.Examples.BitPrecise.BrokenSearch                   , Documentation.SBV.Examples.BitPrecise.Legato                   , Documentation.SBV.Examples.BitPrecise.MergeSort-                  , Documentation.SBV.Examples.BitPrecise.MultMask+                  , Documentation.SBV.Examples.BitPrecise.PEXT_PDEP                   , Documentation.SBV.Examples.BitPrecise.PrefixSum                   , Documentation.SBV.Examples.CodeGeneration.AddSub                   , Documentation.SBV.Examples.CodeGeneration.CRC_USB5@@ -123,10 +145,8 @@                   , Documentation.SBV.Examples.Crypto.Prince                   , Documentation.SBV.Examples.Crypto.SHA                   , Documentation.SBV.Examples.DeltaSat.DeltaSat-                  , Documentation.SBV.Examples.Existentials.CRCPolynomial                   , Documentation.SBV.Examples.Existentials.Diophantine                   , 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@@ -140,6 +160,7 @@                   , Documentation.SBV.Examples.Misc.NoDiv0                   , Documentation.SBV.Examples.Misc.Newtypes                   , Documentation.SBV.Examples.Misc.Polynomials+                  , Documentation.SBV.Examples.Misc.ProgramPaths                   , Documentation.SBV.Examples.Misc.SetAlgebra                   , Documentation.SBV.Examples.Misc.SoftConstrain                   , Documentation.SBV.Examples.Misc.Tuple@@ -148,6 +169,7 @@                   , Documentation.SBV.Examples.Optimization.LinearOpt                   , Documentation.SBV.Examples.Optimization.Production                   , Documentation.SBV.Examples.Optimization.VM+                  , Documentation.SBV.Examples.ProofTools.AddHorn                   , Documentation.SBV.Examples.ProofTools.BMC                   , Documentation.SBV.Examples.ProofTools.Fibonacci                   , Documentation.SBV.Examples.ProofTools.Strengthen@@ -175,6 +197,7 @@                   , Documentation.SBV.Examples.Puzzles.LadyAndTigers                   , Documentation.SBV.Examples.Puzzles.MagicSquare                   , Documentation.SBV.Examples.Puzzles.Murder+                  , Documentation.SBV.Examples.Puzzles.Newspaper                   , Documentation.SBV.Examples.Puzzles.NQueens                   , Documentation.SBV.Examples.Puzzles.Orangutans                   , Documentation.SBV.Examples.Puzzles.Rabbits@@ -232,6 +255,7 @@                   , Data.SBV.Provers.CVC5                   , Data.SBV.Provers.DReal                   , Data.SBV.Provers.MathSAT+                  , Data.SBV.Provers.OpenSMT                   , Data.SBV.Provers.Yices                   , Data.SBV.Provers.Z3                   , Data.SBV.Utils.CrackNum@@ -247,20 +271,6 @@   default-language : Haskell2010   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, sbv, directory, random, mtl, containers, deepseq                   , bytestring, tasty, tasty-golden, tasty-hunit, tasty-quickcheck, QuickCheck   hs-source-dirs  : SBVTestSuite@@ -323,7 +333,6 @@                   , TestSuite.Crypto.AES                   , TestSuite.Crypto.RC4                   , TestSuite.Crypto.SHA-                  , TestSuite.Existentials.CRCPolynomial                   , TestSuite.GenTest.GenTests                   , TestSuite.Optimization.AssertWithPenalty                   , TestSuite.Optimization.Basics@@ -389,20 +398,6 @@     default-language: Haskell2010     build-depends   : base, sbv, process, QuickCheck, filepath, mtl, bytestring, directory                     , tasty, tasty-quickcheck, tasty-golden, tasty-hunit, deepseq-    other-extensions: DataKinds-                      DeriveAnyClass-                      DeriveDataTypeable-                      FlexibleContexts-                      GeneralizedNewtypeDeriving-                      OverloadedLists-                      OverloadedStrings-                      Rank2Types-                      RankNTypes-                      ScopedTypeVariables-                      StandaloneDeriving-                      TemplateHaskell-                      TupleSections-                      TypeApplications     hs-source-dirs  : SBVTestSuite     main-is:          SBVDocTest.hs     other-modules   : Utils.SBVTestFramework@@ -414,20 +409,6 @@      build-depends   : base, directory, filepath, process, deepseq                     , bytestring, tasty, tasty-golden, tasty-hunit, tasty-quickcheck, mtl, QuickCheck, sbv-    other-extensions: DataKinds-                      DeriveAnyClass-                      DeriveDataTypeable-                      FlexibleContexts-                      GeneralizedNewtypeDeriving-                      OverloadedLists-                      OverloadedStrings-                      Rank2Types-                      RankNTypes-                      ScopedTypeVariables-                      StandaloneDeriving-                      TemplateHaskell-                      TupleSections-                      TypeApplications     hs-source-dirs  : SBVTestSuite     other-modules   : Utils.SBVTestFramework     main-is         : SBVHLint.hs@@ -438,20 +419,6 @@   default-language: Haskell2010   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, sbv, random, time , process, deepseq, tasty, tasty-bench   hs-source-dirs  : SBVBenchSuite   main-is         : SBVBench.hs@@ -473,7 +440,6 @@                   , BenchSuite.BitPrecise.BrokenSearch                   , BenchSuite.BitPrecise.Legato                   , BenchSuite.BitPrecise.MergeSort-                  , BenchSuite.BitPrecise.MultMask                   , BenchSuite.BitPrecise.PrefixSum                   , BenchSuite.Queries.AllSat                   , BenchSuite.Queries.CaseSplit@@ -530,9 +496,7 @@                   , 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