diff --git a/CHANGES.md b/CHANGES.md
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,7 +1,32 @@
 * Hackage: <http://hackage.haskell.org/package/sbv>
 * GitHub:  <http://leventerkok.github.com/sbv/>
 
-* Latest Hackage released version: 8.12, 2021-03-09
+* Latest Hackage released version: 8.13, 2021-03-21
+
+### Version 8.13
+
+  * Generalized floating point: Add support for brain-floats, with
+    type `SFPBFloat`, which has 8-bits of exponent and 8-bits of
+    significand. This format is affectionately called "brain-float"
+    because it's often used in modeling neural networks machine-learning
+    applications, offering a wider-range than IEEE's half-float, at the
+    exponse of reduced precision. It has 8-exponent bits and 8-significand
+    bits, including the hidden bit.
+
+  * Add support for SRational type, rational values built out of the ratio
+    of two integers. Use the module "Data.SBV.Rational", which exports the
+    constructor .% to build rationals. Note that you cannot take numerator
+    and denominator of rationals apart, since SMTLib has no way of storing
+    the rational in a canonical way. Otherwise, symbolic rationals follow
+    the same rules as Haskell's Rational type.
+
+  * SBV now implements a faster allSat algorithm, which applies in most common
+    use cases. (Essentially, when there are no uninterpreted values or sorts present.)
+    The new algorithm has been measured to be at least an order of magnitude
+    faster or more in common cases as it splits the search space into disjoint
+    models, reducing the burden of accummulated lemmas over multiple calls. (See
+    http://theory.stanford.edu/%7Enikolaj/programmingz3.html#sec-blocking-evaluations
+    for details.)
 
 ### Version 8.12, 2021-03-09
 
diff --git a/Data/SBV.hs b/Data/SBV.hs
--- a/Data/SBV.hs
+++ b/Data/SBV.hs
@@ -46,16 +46,18 @@
 --
 --   * 'SInteger': Unbounded signed integers.
 --
---   * 'SReal': Algebraic-real numbers
+--   * 'SReal': Algebraic-real numbers.
 --
---   * 'SFloat': IEEE-754 single-precision floating point values
+--   * 'SFloat': IEEE-754 single-precision floating point values.
 --
---   * 'SDouble': IEEE-754 double-precision floating point values
+--   * 'SDouble': IEEE-754 double-precision floating point values.
 --
+--   * 'SRational': Rationals. (Ratio of two symbolic integers.)
+--
 --   * 'SFloatingPoint': Generalized IEEE-754 floating point values, with user specified exponent and
 --   mantissa widths.
 --
---   * 'SChar', 'SString', 'RegExp': Characters, strings and regular expressions
+--   * 'SChar', 'SString', 'RegExp': Characters, strings and regular expressions.
 --
 --   * 'SList': Symbolic lists (which can be nested)
 --
@@ -63,9 +65,9 @@
 --
 --   * 'SEither': Symbolic sums
 --
---   * 'SMaybe': Symbolic optional values
+--   * 'SMaybe': Symbolic optional values.
 --
---   * 'SSet': Symbolic sets
+--   * 'SSet': Symbolic sets.
 --
 --   * 'SArray', 'SFunArray': Flat arrays of symbolic values.
 --
@@ -161,9 +163,12 @@
   , ValidFloat, SFloat, SDouble
   , SFloatingPoint, FloatingPoint
   , SFPHalf, FPHalf
+  , SFPBFloat, FPBFloat
   , SFPSingle, FPSingle
   , SFPDouble, FPDouble
   , SFPQuad, FPQuad
+  -- ** Rationals
+  , SRational
   -- ** Algebraic reals
   -- $algReals
   , SReal, AlgReal(..), sRealToSInteger, algRealToRational, RealPoint(..), realPoint, RationalCV(..)
@@ -191,10 +196,12 @@
   , sInt8,  sInt8_,  sInt16,  sInt16_,  sInt32,  sInt32_,  sInt64,  sInt64_, sInt, sInt_
   , sInteger, sInteger_
   , sReal, sReal_
+  , sRational, sRational_
   , sFloat, sFloat_
   , sDouble, sDouble_
   , sFloatingPoint, sFloatingPoint_
   , sFPHalf, sFPHalf_
+  , sFPBFloat, sFPBFloat_
   , sFPSingle, sFPSingle_
   , sFPDouble, sFPDouble_
   , sFPQuad, sFPQuad_
@@ -213,10 +220,12 @@
   , sInt8s,  sInt16s,  sInt32s,  sInt64s, sInts
   , sIntegers
   , sReals
+  , sRationals
   , sFloats
   , sDoubles
   , sFloatingPoints
   , sFPHalfs
+  , sFPBFloats
   , sFPSingles
   , sFPDoubles
   , sFPQuads
@@ -393,12 +402,13 @@
                                         solve, sBool, sBool_, sBools, sChar, sChar_, sChars,
                                         sDouble, sDouble_, sDoubles, sFloat, sFloat_, sFloats,
                                         sFloatingPoint, sFloatingPoint_, sFloatingPoints,
-                                        sFPHalf, sFPHalf_, sFPHalfs, sFPSingle, sFPSingle_, sFPSingles,
+                                        sFPHalf, sFPHalf_, sFPHalfs, sFPBFloat, sFPBFloat_, sFPBFloats, sFPSingle, sFPSingle_, sFPSingles,
                                         sFPDouble, sFPDouble_, sFPDoubles, sFPQuad, sFPQuad_, sFPQuads,
                                         sInt8, sInt8_, sInt8s, sInt16, sInt16_, sInt16s, sInt32, sInt32_, sInt32s,
                                         sInt64, sInt64_, sInt64s, sInteger, sInteger_, sIntegers,
                                         sList, sList_, sLists, sTuple, sTuple_, sTuples,
                                         sReal, sReal_, sReals, sString, sString_, sStrings,
+                                        sRational, sRational_, sRationals,
                                         sWord8, sWord8_, sWord8s, sWord16, sWord16_, sWord16s,
                                         sWord32, sWord32_, sWord32s, sWord64, sWord64_, sWord64s,
                                         sMaybe, sMaybe_, sMaybes, sEither, sEither_, sEithers, sSet, sSet_, sSets)
diff --git a/Data/SBV/Client.hs b/Data/SBV/Client.hs
--- a/Data/SBV/Client.hs
+++ b/Data/SBV/Client.hs
@@ -68,17 +68,17 @@
                        else ensureEmptyData   typeName
 
     deriveEqOrds <- if isEnum
-                       then [d| deriving instance Eq       $(typeCon)
-                                deriving instance Ord      $(typeCon)
+                       then [d| deriving instance Eq       $typeCon
+                                deriving instance Ord      $typeCon
                             |]
                        else pure []
 
-    derives <- [d| deriving instance Show     $(typeCon)
-                   deriving instance Read     $(typeCon)
-                   deriving instance Data     $(typeCon)
-                   deriving instance SymVal   $(typeCon)
-                   deriving instance HasKind  $(typeCon)
-                   deriving instance SatModel $(typeCon)
+    derives <- [d| deriving instance Show     $typeCon
+                   deriving instance Read     $typeCon
+                   deriving instance Data     $typeCon
+                   deriving instance SymVal   $typeCon
+                   deriving instance HasKind  $typeCon
+                   deriving instance SatModel $typeCon
                |]
 
 
diff --git a/Data/SBV/Client/BaseIO.hs b/Data/SBV/Client/BaseIO.hs
--- a/Data/SBV/Client/BaseIO.hs
+++ b/Data/SBV/Client/BaseIO.hs
@@ -25,10 +25,10 @@
 
 import Data.SBV.Core.Data      (HasKind, Kind, Outputtable, Penalty, SymArray,
                                 SymVal, SBool, SBV, SChar, SDouble, SFloat,
-                                SFPHalf, SFPSingle, SFPDouble, SFPQuad, SFloatingPoint,
+                                SFPHalf, SFPBFloat, SFPSingle, SFPDouble, SFPQuad, SFloatingPoint,
                                 SInt8, SInt16, SInt32, SInt64, SInteger, SList,
                                 SReal, SString, SV, SWord8, SWord16, SWord32,
-                                SWord64, SEither, SMaybe, SSet)
+                                SWord64, SEither, SRational, SMaybe, SSet)
 import Data.SBV.Core.Sized     (SInt, SWord, IntN, WordN)
 import Data.SBV.Core.Kind      (BVIsNonZero, ValidFloat)
 import Data.SBV.Core.Model     (Metric(..), SymTuple)
@@ -663,6 +663,24 @@
 sFPHalfs :: [String] -> Symbolic [SFPHalf]
 sFPHalfs = Trans.sFPHalfs
 
+-- | Declare a named 'SFPBFloat'
+--
+-- NB. For a version which generalizes over the underlying monad, see 'Data.SBV.Trans.SFPBFloat'
+sFPBFloat :: String -> Symbolic SFPBFloat
+sFPBFloat = Trans.sFPBFloat
+
+-- | Declare an unnamed 'SFPBFloat'
+--
+-- NB. For a version which generalizes over the underlying monad, see 'Data.SBV.Trans.SFPBFloat'
+sFPBFloat_ :: Symbolic SFPBFloat
+sFPBFloat_ = Trans.sFPBFloat_
+
+-- | Declare a list of 'SFPQuad's
+--
+-- NB. For a version which generalizes over the underlying monad, see 'Data.SBV.Trans.sFPBFloats'
+sFPBFloats :: [String] -> Symbolic [SFPBFloat]
+sFPBFloats = Trans.sFPBFloats
+
 -- | Declare a named 'SFPSingle'
 --
 -- NB. For a version which generalizes over the underlying monad, see 'Data.SBV.Trans.sFPSingle'
@@ -806,6 +824,24 @@
 -- NB. For a version which generalizes over the underlying monad, see 'Data.SBV.Trans.sEithers'
 sEithers :: (SymVal a, SymVal b) => [String] -> Symbolic [SEither a b]
 sEithers = Trans.sEithers
+
+-- | Declare a named 'Data.SBV.SRational'.
+--
+-- NB. For a version which generalizes over the underlying monad, see 'Data.SBV.Trans.sRational'
+sRational :: String -> Symbolic SRational
+sRational = Trans.sRational
+
+-- | Declare an unnamed 'Data.SBV.SRational'.
+--
+-- NB. For a version which generalizes over the underlying monad, see 'Data.SBV.Trans.sRational_'
+sRational_ :: Symbolic SRational
+sRational_ = Trans.sRational_
+
+-- | Declare a list of 'Data.SBV.SRational' values.
+--
+-- NB. For a version which generalizes over the underlying monad, see 'Data.SBV.Trans.sRationals'
+sRationals :: [String] -> Symbolic [SRational]
+sRationals = Trans.sRationals
 
 -- | Declare a named 'Data.SBV.SMaybe'.
 --
diff --git a/Data/SBV/Compilers/C.hs b/Data/SBV/Compilers/C.hs
--- a/Data/SBV/Compilers/C.hs
+++ b/Data/SBV/Compilers/C.hs
@@ -201,6 +201,7 @@
                      KDouble       -> specF CgDouble
                      KString       -> text "%s"
                      KChar         -> text "%c"
+                     KRational     -> die   "rational sort"
                      KFP{}         -> die   "arbitrary float sort"
                      KList k       -> die $ "list sort: " ++ show k
                      KSet  k       -> die $ "set sort: " ++ show k
@@ -521,6 +522,7 @@
                       len KBool              = 5 -- SBool
                       len (KBounded False n) = 5 + length (show n) -- SWordN
                       len (KBounded True  n) = 4 + length (show n) -- SIntN
+                      len KRational{}        = die   "Rational."
                       len KFP{}              = die   "Arbitrary float."
                       len (KList s)          = die $ "List sort: " ++ show s
                       len (KSet  s)          = die $ "Set sort: " ++ show s
@@ -779,6 +781,7 @@
                                                KFloat          -> die "array index with float value"
                                                KDouble         -> die "array index with double value"
                                                KFP{}           -> die "array index with arbitrary float value"
+                                               KRational       -> die "array index with rational value"
                                                KString         -> die "array index with string value"
                                                KChar           -> die "array index with character value"
                                                KUnbounded      -> case cgInteger cfg of
diff --git a/Data/SBV/Control/Query.hs b/Data/SBV/Control/Query.hs
--- a/Data/SBV/Control/Query.hs
+++ b/Data/SBV/Control/Query.hs
@@ -64,6 +64,8 @@
 import Data.SBV.Control.Types
 import Data.SBV.Control.Utils
 
+import Data.SBV.Utils.PrettyNum (showNegativeNumber)
+
 -- | An Assignment of a model binding
 data Assignment = Assign SVal CV
 
@@ -99,20 +101,14 @@
 serialize :: Bool -> SExpr -> String
 serialize removeQuotes = go
   where go (ECon s)           = if removeQuotes then unQuote s else s
-        go (ENum (i, _))      = shNN i
-        go (EReal   r)        = shNN r
-        go (EFloat  f)        = shNN f
-        go (EDouble d)        = shNN d
+        go (ENum (i, _))      = showNegativeNumber i
+        go (EReal   r)        = showNegativeNumber r
+        go (EFloat  f)        = showNegativeNumber f
+        go (EDouble d)        = showNegativeNumber d
         go (EFloatingPoint f) = show f
         go (EApp [x])         = go x
         go (EApp ss)          = "(" ++ unwords (map go ss) ++ ")"
 
-        -- be careful with negative number printing in SMT-Lib..
-        shNN :: (Show a, Num a, Ord a) => a -> String
-        shNN i
-          | i < 0 = "(- " ++ show (-i) ++ ")"
-          | True  = show i
-
 -- | Generalization of 'Data.SBV.Control.getInfo'
 getInfo :: (MonadIO m, MonadQuery m) => SMTInfoFlag -> m SMTInfoResponse
 getInfo flag = do
@@ -838,4 +834,4 @@
 
              return $ Satisfiable queryConfig m
 
-{-# ANN getModelAtIndex ("HLint: ignore Use forM_"          :: String) #-}
+{-# ANN getModelAtIndex ("HLint: ignore Use forM_" :: String) #-}
diff --git a/Data/SBV/Control/Utils.hs b/Data/SBV/Control/Utils.hs
--- a/Data/SBV/Control/Utils.hs
+++ b/Data/SBV/Control/Utils.hs
@@ -56,16 +56,17 @@
 import qualified Data.Sequence      as S
 import qualified Data.Text          as T
 
-import Control.Monad            (join, unless, zipWithM, when, replicateM)
+import Control.Monad            (join, unless, zipWithM, when, replicateM, forM_)
 import Control.Monad.IO.Class   (MonadIO, liftIO)
 import Control.Monad.Trans      (lift)
 import Control.Monad.Reader     (runReaderT)
 
 import Data.Maybe (isNothing, isJust)
 
-import Data.IORef (readIORef, writeIORef, IORef)
+import Data.IORef (readIORef, writeIORef, IORef, newIORef, modifyIORef')
 
 import Data.Time (getZonedTime)
+import Data.Ratio
 
 import Data.SBV.Core.Data     ( SV(..), trueSV, falseSV, CV(..), trueCV, falseCV, SBV, sbvToSV, kindOf, Kind(..)
                               , HasKind(..), mkConstCV, CVal(..), SMTResult(..)
@@ -91,7 +92,7 @@
 import Data.SBV.Core.AlgReals    (mergeAlgReals, AlgReal(..), RealPoint(..))
 import Data.SBV.Core.SizedFloats (fpZero, fpFromInteger, fpFromFloat, fpFromDouble)
 import Data.SBV.Core.Kind        (smtType, hasUninterpretedSorts)
-import Data.SBV.Core.Operations  (svNot, svNotEqual, svOr)
+import Data.SBV.Core.Operations  (svNot, svNotEqual, svOr, svEqual)
 
 import Data.SBV.SMT.SMT     (showModel, parseCVs, SatModel, AllSatResult(..))
 import Data.SBV.SMT.SMTLib  (toIncSMTLib, toSMTLib)
@@ -729,6 +730,7 @@
         cvt (KUserSort _ ui) = uninterp ui
         cvt KFloat           = Just $ CFloat 0
         cvt KDouble          = Just $ CDouble 0
+        cvt KRational        = Just $ CRational 0
         cvt (KFP eb sb)      = Just $ CFP (fpZero False eb sb)
         cvt KChar            = Just $ CChar '\NUL'                -- why not?
         cvt KString          = Just $ CString ""
@@ -786,6 +788,8 @@
                            KString     | ECon s      <- e      -> Just $ CV KString $ CString $ interpretString s
                                        | True                  -> Nothing
 
+                           KRational                           -> Just $ CV k $ CRational $ interpretRational e
+
                            KList ek                            -> Just $ CV k $ CList $ interpretList ek e
 
                            KSet ek                             -> Just $ CV k $ CSet $ interpretSet ek e
@@ -812,6 +816,12 @@
                              [c] -> c
                              _   -> error $ "Expected a singleton char constant, received: <" ++ xs ++ ">"
 
+        interpretRational (EApp [ECon "SBV.Rational", v1, v2])
+           | Just (CV _ (CInteger n)) <- recoverKindedValue KUnbounded v1
+           , Just (CV _ (CInteger d)) <- recoverKindedValue KUnbounded v2
+           = n % d
+        interpretRational xs = error $ "Expected a rational constant, received: <" ++ show xs ++ ">"
+
         interpretList ek topExpr = walk topExpr
           where walk (EApp [ECon "as", ECon "seq.empty", _]) = []
                 walk (EApp [ECon "seq.unit", v])             = case recoverKindedValue ek v of
@@ -1114,7 +1124,7 @@
                       -- Functions have at least two kinds in their type and all components must be "interpreted"
                      let allUiFuns = [u | satTrackUFs cfg                                         -- config says consider UIFs
                                         , u@(nm, SBVType as) <- allUninterpreteds, length as > 1  -- get the function ones
-                                        , not (isNonModelVar cfg nm)                               -- make sure they aren't explicitly ignored
+                                        , not (isNonModelVar cfg nm)                              -- make sure they aren't explicitly ignored
                                      ]
 
                          allUiRegs = [u | u@(nm, SBVType as) <- allUninterpreteds, length as == 1  -- non-function ones
@@ -1168,41 +1178,179 @@
                          -- If we have any universals, then the solutions are unique upto prefix existentials.
                          w = ALL `elem` F.toList (quantifier <$> qinps)
 
-                     res <- loop grabObservables topState (allUiFuns, uiFuns) allUiRegs qinps vars cfg AllSatResult { allSatMaxModelCountReached  = False
-                                                                                                                    , allSatHasPrefixExistentials = w
-                                                                                                                    , allSatSolverReturnedUnknown = False
-                                                                                                                    , allSatSolverReturnedDSat    = False
-                                                                                                                    , allSatResults               = []
-                                                                                                                    }
-                     -- results come out in reverse order, so reverse them:
-                     pure $ res { allSatResults = reverse (allSatResults res) }
 
+                     -- We can go fast using the disjoint model trick if things are simple enough
+                     --     - Nothing uninterpreted
+                     --     - No uninterpreted sorts
+                     -- The idea is originally due to z3 folks, see: <http://theory.stanford.edu/%7Enikolaj/programmingz3.html#sec-blocking-evaluations>
+                     let isSimple = null allUninterpreteds && null usorts
+
+                         start = AllSatResult { allSatMaxModelCountReached  = False
+                                              , allSatHasPrefixExistentials = w
+                                              , allSatSolverReturnedUnknown = False
+                                              , allSatSolverReturnedDSat    = False
+                                              , allSatResults               = []
+                                              }
+
+                     if isSimple
+                        then fastAllSat grabObservables                                        qinps vars cfg start
+                        else loop       grabObservables topState (allUiFuns, uiFuns) allUiRegs qinps vars cfg start
+
    where isFree (KUserSort _ Nothing) = True
          isFree _                     = False
 
+         finalize cnt cfg sofar extra
+                = when (allSatPrintAlong cfg && not (null (allSatResults sofar))) $ do
+                           let msg 0 = "No solutions found."
+                               msg 1 = "This is the only solution."
+                               msg n = "Found " ++ show n ++ " different solutions."
+                           io . putStrLn $ msg (cnt - 1)
+                           case extra of
+                             Nothing -> pure ()
+                             Just m  -> io $ putStrLn m
+
+         fastAllSat :: Bool -> S.Seq (Quantifier, NamedSymVar) -> S.Seq (SVal, NamedSymVar) -> SMTConfig -> AllSatResult -> m AllSatResult
+         fastAllSat grabObservables qinps vars cfg start = do
+                result <- io $ newIORef (0, start, False, Nothing)
+                go result vars
+                (found, sofar, _, extra) <- io $ readIORef result
+                finalize (found+1) cfg sofar extra
+                pure sofar
+
+           where haveEnough have = case allSatMaxModelCount cfg of
+                                     Just maxModels -> have >= maxModels
+                                     _              -> False
+
+                 go :: IORef (Int, AllSatResult, Bool, Maybe String) -> S.Seq (SVal, NamedSymVar) -> m ()
+                 go finalResult = walk True
+                   where shouldContinue = do (have, _, exitLoop, _) <- io $ readIORef finalResult
+                                             pure $ not (exitLoop || haveEnough have)
+
+                         walk :: Bool -> S.Seq (SVal, NamedSymVar) -> m ()
+                         walk firstRun terms
+                           | not firstRun && S.null terms
+                           = pure ()
+                           | True
+                           = do mbCont <- do (have, sofar, exitLoop, _) <- io $ readIORef finalResult
+                                             if exitLoop
+                                                then pure Nothing
+                                                else case allSatMaxModelCount cfg of
+                                                       Just maxModels
+                                                         | have >= maxModels -> do unless (allSatMaxModelCountReached sofar) $ do
+                                                                                      queryDebug ["*** Maximum model count request of " ++ show maxModels ++ " reached, stopping the search."]
+                                                                                      when (allSatPrintAlong cfg) $ io $ putStrLn "Search stopped since model count request was reached."
+                                                                                      io $ modifyIORef' finalResult $ \(h, s, _, m) -> (h, s{ allSatMaxModelCountReached = True }, True, m)
+                                                                                   pure Nothing
+                                                       _                     -> pure $ Just $ have+1
+
+                                case mbCont of
+                                  Nothing  -> pure ()
+                                  Just cnt -> do
+                                    queryDebug ["Fast allSat, Looking for solution " ++ show cnt]
+
+                                    cs <- checkSat
+
+                                    case cs of
+                                      Unsat  -> pure ()
+
+                                      Unk    -> do let m = "Solver returned unknown, terminating query."
+                                                   queryDebug ["*** " ++ m]
+                                                   io $ modifyIORef' finalResult $ \(h, s, _, _) -> (h, s{allSatSolverReturnedUnknown = True}, True, Just ("[" ++ m ++ "]"))
+
+                                      DSat _ -> do let m = "Solver returned delta-sat, terminating query."
+                                                   queryDebug ["*** " ++ m]
+                                                   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
+
+                                                   bindings <- let grab i@(ALL, _)          = return (i, Nothing)
+                                                                   grab i@(EX, getSV -> sv) = case lookupInput fst sv assocs of
+                                                                                                Just (_, (_, (_, cv))) -> return (i, Just cv)
+                                                                                                Nothing                -> do !cv <- getValueCV Nothing sv
+                                                                                                                             return (i, Just cv)
+                                                               in if validationRequested cfg
+                                                                  then Just <$> mapM grab qinps
+                                                                  else return Nothing
+
+                                                   -- Add on observables if we're asked to do so:
+                                                   obsvs <- if grabObservables
+                                                               then getObservables
+                                                               else do queryDebug ["*** In a quantified context, observables will not be printed."]
+                                                                       return mempty
+
+                                                   let lassocs = F.toList assocs
+                                                       model   = SMTModel { modelObjectives = []
+                                                                          , modelBindings   = F.toList <$> bindings
+                                                                          , modelAssocs     =    (first T.unpack <$> sortOn fst obsvs)
+                                                                                              <> [(T.unpack n, cv) | (_, (n, (_, cv))) <- lassocs]
+                                                                          , modelUIFuns     = []
+                                                                          }
+                                                       currentResult = Satisfiable cfg model
+
+                                                   io $ modifyIORef' finalResult $ \(h, s, e, m) -> let h' = h+1 in h' `seq` (h', s{allSatResults = currentResult : allSatResults s}, e, m)
+
+                                                   when (allSatPrintAlong cfg) $ do
+                                                        io $ putStrLn $ "Solution #" ++ show cnt ++ ":"
+                                                        io $ putStrLn $ showModel cfg model
+
+                                                   let findVal :: (SVal, NamedSymVar) -> (SVal, CV)
+                                                       findVal (_, NamedSymVar sv nm) = case F.toList (S.filter (\(sv', _) -> sv == sv') assocs) of
+                                                                                           [(_, (_, scv))] -> scv
+                                                                                           _               -> error $ "Data.SBV: Cannot uniquely determine " ++ show nm ++ " in " ++ show assocs
+
+                                                       cstr :: Bool -> (SVal, CV) -> m ()
+                                                       cstr shouldReject (sv, cv) = constrain $ SBV $ mkEq (kindOf sv) sv (SVal (kindOf sv) (Left cv))
+                                                         where mkEq :: Kind -> SVal -> SVal -> SVal
+                                                               mkEq k a b
+                                                                | isDouble k || isFloat k || isFP k
+                                                                = if shouldReject
+                                                                     then svNot  (a `fpEq` b)
+                                                                     else         a `fpEq` b
+                                                                | True
+                                                                = if shouldReject
+                                                                     then a `svNotEqual` b
+                                                                     else a `svEqual`    b
+
+                                                               fpEq a b = SVal KBool $ Right $ cache r
+                                                                   where r st = do sva <- svToSV st a
+                                                                                   svb <- svToSV st b
+                                                                                   newExpr st KBool (SBVApp (IEEEFP FP_ObjEqual) [sva, svb])
+
+                                                       reject, accept :: (SVal, NamedSymVar) -> m ()
+                                                       reject = cstr True  . findVal
+                                                       accept = cstr False . findVal
+
+                                                       scope :: (SVal, NamedSymVar) -> S.Seq (SVal, NamedSymVar) -> m () -> m ()
+                                                       scope cur pres c = do
+                                                                send True "(push 1)"
+                                                                reject cur
+                                                                sequence_ $ accept <$> pres
+                                                                r <- c
+                                                                send True "(pop 1)"
+                                                                pure r
+
+                                                   forM_ [0 .. length terms - 1] $ \i -> do
+                                                        sc <- shouldContinue
+                                                        when sc $ do let (pre, rest@(cur S.:<| _)) = S.splitAt i terms
+                                                                     scope cur pre $ walk False rest
+
+         -- All sat loop. This is slower, as it implements the reject-the-previous model and loop around logic. But
+         -- it can handle uninterpreted sorts; so we keep it here as a fall-back.
          loop grabObservables topState (allUiFuns, uiFunsToReject) allUiRegs qinps vars cfg = go (1::Int)
            where go :: Int -> AllSatResult -> m AllSatResult
                  go !cnt !sofar
                    | Just maxModels <- allSatMaxModelCount cfg, cnt > maxModels
                    = do queryDebug ["*** Maximum model count request of " ++ show maxModels ++ " reached, stopping the search."]
-
                         when (allSatPrintAlong cfg) $ io $ putStrLn "Search stopped since model count request was reached."
-
                         return $! sofar { allSatMaxModelCountReached = True }
                    | True
                    = do queryDebug ["Looking for solution " ++ show cnt]
 
-                        let endMsg extra = when (allSatPrintAlong cfg && not (null (allSatResults sofar))) $ do
-                                              let msg 0 = "No solutions found."
-                                                  msg 1 = "This is the only solution."
-                                                  msg n = "Found " ++ show n ++ " different solutions."
-                                              io . putStrLn $ msg (cnt - 1)
-                                              case extra of
-                                                Nothing -> pure ()
-                                                Just m  -> io $ putStrLn m
-
                         cs <- checkSat
 
+                        let endMsg = finalize cnt cfg sofar
+
                         case cs of
                           Unsat  -> do endMsg Nothing
                                        return sofar
@@ -1266,11 +1414,11 @@
                                            interpretedEqs = [mkNotEq (kindOf sv) sv (SVal (kindOf sv) (Left cv)) | (sv, cv) <- interpretedRegUiSVs <> F.toList interpreteds]
                                               where mkNotEq k a b
                                                      | isDouble k || isFloat k || isFP k
-                                                     = svNot (a `fpNotEq` b)
+                                                     = svNot (a `fpEq` b)
                                                      | True
                                                      = a `svNotEqual` b
 
-                                                    fpNotEq a b = SVal KBool $ Right $ cache r
+                                                    fpEq a b = SVal KBool $ Right $ cache r
                                                         where r st = do sva <- svToSV st a
                                                                         svb <- svToSV st b
                                                                         newExpr st KBool (SBVApp (IEEEFP FP_ObjEqual) [sva, svb])
diff --git a/Data/SBV/Core/Concrete.hs b/Data/SBV/Core/Concrete.hs
--- a/Data/SBV/Core/Concrete.hs
+++ b/Data/SBV/Core/Concrete.hs
@@ -76,6 +76,7 @@
           | CFloat    !Float               -- ^ Float
           | CDouble   !Double              -- ^ Double
           | CFP       !FP                  -- ^ Arbitrary float
+          | CRational Rational             -- ^ Rational
           | CChar     !Char                -- ^ Character
           | CString   !String              -- ^ String
           | CList     ![CVal]              -- ^ List
@@ -92,14 +93,15 @@
 cvRank CFloat    {} =  2
 cvRank CDouble   {} =  3
 cvRank CFP       {} =  4
-cvRank CChar     {} =  5
-cvRank CString   {} =  6
-cvRank CList     {} =  7
-cvRank CSet      {} =  8
-cvRank CUserSort {} =  9
-cvRank CTuple    {} = 10
-cvRank CMaybe    {} = 11
-cvRank CEither   {} = 12
+cvRank CRational {} =  5
+cvRank CChar     {} =  6
+cvRank CString   {} =  7
+cvRank CList     {} =  8
+cvRank CSet      {} =  9
+cvRank CUserSort {} = 10
+cvRank CTuple    {} = 11
+cvRank CMaybe    {} = 12
+cvRank CEither   {} = 13
 
 -- | Eq instance for CVVal. Note that we cannot simply derive Eq/Ord, since CVAlgReal doesn't have proper
 -- instances for these when values are infinitely precise reals. However, we do
@@ -109,6 +111,7 @@
   CInteger  a == CInteger  b = a == b
   CFloat    a == CFloat    b = a `fpIsEqualObjectH` b   -- We don't want +0/-0 to be confused; and also we want NaN = NaN here!
   CDouble   a == CDouble   b = a `fpIsEqualObjectH` b   -- ditto
+  CRational a == CRational b = a == b
   CChar     a == CChar     b = a == b
   CString   a == CString   b = a == b
   CList     a == CList     b = a == b
@@ -133,6 +136,7 @@
   CInteger  a `compare` CInteger  b = a `compare`                  b
   CFloat    a `compare` CFloat    b = a `fpCompareObjectH`         b
   CDouble   a `compare` CDouble   b = a `fpCompareObjectH`         b
+  CRational a `compare` CRational b = a `compare`                  b
   CFP       a `compare` CFP       b = a `fprCompareObject`         b
   CChar     a `compare` CChar     b = a `compare`                  b
   CString   a `compare` CString   b = a `compare`                  b
@@ -277,6 +281,7 @@
        -> (Float               -> b)
        -> (Double              -> b)
        -> (FP                  -> b)
+       -> (Rational            -> b)
        -> (Char                -> b)
        -> (String              -> b)
        -> ((Maybe Int, String) -> b)
@@ -287,19 +292,20 @@
        -> (Either CVal CVal    -> b)
        -> CV
        -> b
-liftCV f _ _ _ _ _ _ _ _ _ _ _ _ (CV _ (CAlgReal  v)) = f v
-liftCV _ f _ _ _ _ _ _ _ _ _ _ _ (CV _ (CInteger  v)) = f v
-liftCV _ _ f _ _ _ _ _ _ _ _ _ _ (CV _ (CFloat    v)) = f v
-liftCV _ _ _ f _ _ _ _ _ _ _ _ _ (CV _ (CDouble   v)) = f v
-liftCV _ _ _ _ f _ _ _ _ _ _ _ _ (CV _ (CFP       v)) = f v
-liftCV _ _ _ _ _ f _ _ _ _ _ _ _ (CV _ (CChar     v)) = f v
-liftCV _ _ _ _ _ _ f _ _ _ _ _ _ (CV _ (CString   v)) = f v
-liftCV _ _ _ _ _ _ _ f _ _ _ _ _ (CV _ (CUserSort v)) = f v
-liftCV _ _ _ _ _ _ _ _ f _ _ _ _ (CV _ (CList     v)) = f v
-liftCV _ _ _ _ _ _ _ _ _ f _ _ _ (CV _ (CSet      v)) = f v
-liftCV _ _ _ _ _ _ _ _ _ _ f _ _ (CV _ (CTuple    v)) = f v
-liftCV _ _ _ _ _ _ _ _ _ _ _ f _ (CV _ (CMaybe    v)) = f v
-liftCV _ _ _ _ _ _ _ _ _ _ _ _ f (CV _ (CEither   v)) = f v
+liftCV f _ _ _ _ _ _ _ _ _ _ _ _ _ (CV _ (CAlgReal  v)) = f v
+liftCV _ f _ _ _ _ _ _ _ _ _ _ _ _ (CV _ (CInteger  v)) = f v
+liftCV _ _ f _ _ _ _ _ _ _ _ _ _ _ (CV _ (CFloat    v)) = f v
+liftCV _ _ _ f _ _ _ _ _ _ _ _ _ _ (CV _ (CDouble   v)) = f v
+liftCV _ _ _ _ f _ _ _ _ _ _ _ _ _ (CV _ (CFP       v)) = f v
+liftCV _ _ _ _ _ f _ _ _ _ _ _ _ _ (CV _ (CRational v)) = f v
+liftCV _ _ _ _ _ _ f _ _ _ _ _ _ _ (CV _ (CChar     v)) = f v
+liftCV _ _ _ _ _ _ _ f _ _ _ _ _ _ (CV _ (CString   v)) = f v
+liftCV _ _ _ _ _ _ _ _ f _ _ _ _ _ (CV _ (CUserSort v)) = f v
+liftCV _ _ _ _ _ _ _ _ _ f _ _ _ _ (CV _ (CList     v)) = f v
+liftCV _ _ _ _ _ _ _ _ _ _ f _ _ _ (CV _ (CSet      v)) = f v
+liftCV _ _ _ _ _ _ _ _ _ _ _ f _ _ (CV _ (CTuple    v)) = f v
+liftCV _ _ _ _ _ _ _ _ _ _ _ _ f _ (CV _ (CMaybe    v)) = f v
+liftCV _ _ _ _ _ _ _ _ _ _ _ _ _ f (CV _ (CEither   v)) = f v
 
 -- | Lift a binary function through a 'CV'.
 liftCV2 :: (AlgReal             -> AlgReal             -> b)
@@ -336,25 +342,27 @@
       -> (Float               -> Float)
       -> (Double              -> Double)
       -> (FP                  -> FP)
+      -> (Rational            -> Rational)
       -> (Char                -> Char)
       -> (String              -> String)
       -> ((Maybe Int, String) -> (Maybe Int, String))
       -> CV
       -> CV
-mapCV r i f d af c s u x  = normCV $ CV (kindOf x) $ case cvVal x of
-                                                       CAlgReal  a -> CAlgReal  (r  a)
-                                                       CInteger  a -> CInteger  (i  a)
-                                                       CFloat    a -> CFloat    (f  a)
-                                                       CDouble   a -> CDouble   (d  a)
-                                                       CFP       a -> CFP       (af a)
-                                                       CChar     a -> CChar     (c  a)
-                                                       CString   a -> CString   (s  a)
-                                                       CUserSort a -> CUserSort (u  a)
-                                                       CList{}     -> error "Data.SBV.mapCV: Unexpected call through mapCV with lists!"
-                                                       CSet{}      -> error "Data.SBV.mapCV: Unexpected call through mapCV with sets!"
-                                                       CTuple{}    -> error "Data.SBV.mapCV: Unexpected call through mapCV with tuples!"
-                                                       CMaybe{}    -> error "Data.SBV.mapCV: Unexpected call through mapCV with maybe!"
-                                                       CEither{}   -> error "Data.SBV.mapCV: Unexpected call through mapCV with either!"
+mapCV r i f d af ra c s u x  = normCV $ CV (kindOf x) $ case cvVal x of
+                                                          CAlgReal  a -> CAlgReal  (r  a)
+                                                          CInteger  a -> CInteger  (i  a)
+                                                          CFloat    a -> CFloat    (f  a)
+                                                          CDouble   a -> CDouble   (d  a)
+                                                          CFP       a -> CFP       (af a)
+                                                          CRational a -> CRational (ra a)
+                                                          CChar     a -> CChar     (c  a)
+                                                          CString   a -> CString   (s  a)
+                                                          CUserSort a -> CUserSort (u  a)
+                                                          CList{}     -> error "Data.SBV.mapCV: Unexpected call through mapCV with lists!"
+                                                          CSet{}      -> error "Data.SBV.mapCV: Unexpected call through mapCV with sets!"
+                                                          CTuple{}    -> error "Data.SBV.mapCV: Unexpected call through mapCV with tuples!"
+                                                          CMaybe{}    -> error "Data.SBV.mapCV: Unexpected call through mapCV with maybe!"
+                                                          CEither{}   -> error "Data.SBV.mapCV: Unexpected call through mapCV with either!"
 
 -- | Map a binary function through a 'CV'.
 mapCV2 :: (AlgReal             -> AlgReal             -> AlgReal)
@@ -362,26 +370,28 @@
        -> (Float               -> Float               -> Float)
        -> (Double              -> Double              -> Double)
        -> (FP                  -> FP                  -> FP)
+       -> (Rational            -> Rational            -> Rational)
        -> (Char                -> Char                -> Char)
        -> (String              -> String              -> String)
        -> ((Maybe Int, String) -> (Maybe Int, String) -> (Maybe Int, String))
        -> CV
        -> CV
        -> CV
-mapCV2 r i f d af c s u x y = case (cvSameType x y, cvVal x, cvVal y) of
-                                (True, CAlgReal  a, CAlgReal  b) -> normCV $ CV (kindOf x) (CAlgReal  (r  a b))
-                                (True, CInteger  a, CInteger  b) -> normCV $ CV (kindOf x) (CInteger  (i  a b))
-                                (True, CFloat    a, CFloat    b) -> normCV $ CV (kindOf x) (CFloat    (f  a b))
-                                (True, CDouble   a, CDouble   b) -> normCV $ CV (kindOf x) (CDouble   (d  a b))
-                                (True, CFP       a, CFP       b) -> normCV $ CV (kindOf x) (CFP       (af a b))
-                                (True, CChar     a, CChar     b) -> normCV $ CV (kindOf x) (CChar     (c  a b))
-                                (True, CString   a, CString   b) -> normCV $ CV (kindOf x) (CString   (s  a b))
-                                (True, CUserSort a, CUserSort b) -> normCV $ CV (kindOf x) (CUserSort (u  a b))
-                                (True, CList{},     CList{})     -> error "Data.SBV.mapCV2: Unexpected call through mapCV2 with lists!"
-                                (True, CTuple{},    CTuple{})    -> error "Data.SBV.mapCV2: Unexpected call through mapCV2 with tuples!"
-                                (True, CMaybe{},    CMaybe{})    -> error "Data.SBV.mapCV2: Unexpected call through mapCV2 with maybes!"
-                                (True, CEither{},   CEither{})   -> error "Data.SBV.mapCV2: Unexpected call through mapCV2 with eithers!"
-                                _                                -> error $ "Data.SBV.mapCV2: impossible, incompatible args received: " ++ show (x, y)
+mapCV2 r i f d af ra c s u x y = case (cvSameType x y, cvVal x, cvVal y) of
+                                  (True, CAlgReal  a, CAlgReal  b) -> normCV $ CV (kindOf x) (CAlgReal  (r  a b))
+                                  (True, CInteger  a, CInteger  b) -> normCV $ CV (kindOf x) (CInteger  (i  a b))
+                                  (True, CFloat    a, CFloat    b) -> normCV $ CV (kindOf x) (CFloat    (f  a b))
+                                  (True, CDouble   a, CDouble   b) -> normCV $ CV (kindOf x) (CDouble   (d  a b))
+                                  (True, CFP       a, CFP       b) -> normCV $ CV (kindOf x) (CFP       (af a b))
+                                  (True, CRational a, CRational b) -> normCV $ CV (kindOf x) (CRational (ra a b))
+                                  (True, CChar     a, CChar     b) -> normCV $ CV (kindOf x) (CChar     (c  a b))
+                                  (True, CString   a, CString   b) -> normCV $ CV (kindOf x) (CString   (s  a b))
+                                  (True, CUserSort a, CUserSort b) -> normCV $ CV (kindOf x) (CUserSort (u  a b))
+                                  (True, CList{},     CList{})     -> error "Data.SBV.mapCV2: Unexpected call through mapCV2 with lists!"
+                                  (True, CTuple{},    CTuple{})    -> error "Data.SBV.mapCV2: Unexpected call through mapCV2 with tuples!"
+                                  (True, CMaybe{},    CMaybe{})    -> error "Data.SBV.mapCV2: Unexpected call through mapCV2 with maybes!"
+                                  (True, CEither{},   CEither{})   -> error "Data.SBV.mapCV2: Unexpected call through mapCV2 with eithers!"
+                                  _                                -> error $ "Data.SBV.mapCV2: impossible, incompatible args received: " ++ show (x, y)
 
 -- | Show instance for 'CV'.
 instance Show CV where
@@ -395,7 +405,7 @@
 -- | Show a CV, with kind info if bool is True
 showCV :: Bool -> CV -> String
 showCV shk w | isBoolean w = show (cvToBool w) ++ (if shk then " :: Bool" else "")
-showCV shk w               = liftCV show show show show show show show snd shL shS shT shMaybe shEither w ++ kInfo
+showCV shk w               = liftCV show show show show show show show show snd shL shS shT shMaybe shEither w ++ kInfo
       where kw = kindOf w
 
             kInfo | shk  = " :: " ++ showBaseKind kw
@@ -446,13 +456,14 @@
 
 -- | Create a constant word from an integral.
 mkConstCV :: Integral a => Kind -> a -> CV
-mkConstCV KBool           a = normCV $ CV KBool      (CInteger (toInteger a))
-mkConstCV k@KBounded{}    a = normCV $ CV k          (CInteger (toInteger a))
-mkConstCV KUnbounded      a = normCV $ CV KUnbounded (CInteger (toInteger a))
-mkConstCV KReal           a = normCV $ CV KReal      (CAlgReal (fromInteger (toInteger a)))
-mkConstCV KFloat          a = normCV $ CV KFloat     (CFloat   (fromInteger (toInteger a)))
-mkConstCV KDouble         a = normCV $ CV KDouble    (CDouble  (fromInteger (toInteger a)))
-mkConstCV k@KFP{}         a = normCV $ CV k          (CFP      (fromInteger (toInteger a)))
+mkConstCV KBool           a = normCV $ CV KBool      (CInteger  (toInteger a))
+mkConstCV k@KBounded{}    a = normCV $ CV k          (CInteger  (toInteger a))
+mkConstCV KUnbounded      a = normCV $ CV KUnbounded (CInteger  (toInteger a))
+mkConstCV KReal           a = normCV $ CV KReal      (CAlgReal  (fromInteger (toInteger a)))
+mkConstCV KFloat          a = normCV $ CV KFloat     (CFloat    (fromInteger (toInteger a)))
+mkConstCV KDouble         a = normCV $ CV KDouble    (CDouble   (fromInteger (toInteger a)))
+mkConstCV k@KFP{}         a = normCV $ CV k          (CFP       (fromInteger (toInteger a)))
+mkConstCV KRational       a = normCV $ CV KRational  (CRational (fromInteger (toInteger a)))
 mkConstCV KChar           a = error $ "Unexpected call to mkConstCV (Char) with value: "   ++ show (toInteger a)
 mkConstCV KString         a = error $ "Unexpected call to mkConstCV (String) with value: " ++ show (toInteger a)
 mkConstCV (KUserSort s _) a = error $ "Unexpected call to mkConstCV with user kind: " ++ s ++ " with value: " ++ show (toInteger a)
@@ -466,12 +477,13 @@
 randomCVal :: Kind -> IO CVal
 randomCVal k =
   case k of
-    KBool              -> CInteger <$> randomRIO (0, 1)
-    KBounded s w       -> CInteger <$> randomRIO (bounds s w)
-    KUnbounded         -> CInteger <$> randomIO
-    KReal              -> CAlgReal <$> randomIO
-    KFloat             -> CFloat   <$> randomIO
-    KDouble            -> CDouble  <$> randomIO
+    KBool              -> CInteger  <$> randomRIO (0, 1)
+    KBounded s w       -> CInteger  <$> randomRIO (bounds s w)
+    KUnbounded         -> CInteger  <$> randomIO
+    KReal              -> CAlgReal  <$> randomIO
+    KFloat             -> CFloat    <$> randomIO
+    KDouble            -> CDouble   <$> randomIO
+    KRational          -> CRational <$> randomIO
 
     -- Rather bad, but OK
     KFP eb sb          -> do sgn <- randomRIO (0 :: Integer, 1)
diff --git a/Data/SBV/Core/Data.hs b/Data/SBV/Core/Data.hs
--- a/Data/SBV/Core/Data.hs
+++ b/Data/SBV/Core/Data.hs
@@ -28,7 +28,8 @@
 module Data.SBV.Core.Data
  ( SBool, SWord8, SWord16, SWord32, SWord64
  , SInt8, SInt16, SInt32, SInt64, SInteger, SReal, SFloat, SDouble
- , SFloatingPoint, SFPHalf, SFPSingle, SFPDouble, SFPQuad
+ , SFloatingPoint, SFPHalf, SFPBFloat, SFPSingle, SFPDouble, SFPQuad
+ , SRational
  , SChar, SString, SList
  , SEither, SMaybe
  , STuple, STuple2, STuple3, STuple4, STuple5, STuple6, STuple7, STuple8
@@ -154,6 +155,9 @@
 -- | A symbolic half-precision float
 type SFPHalf = SBV FPHalf
 
+-- | A symbolic brain-float precision float
+type SFPBFloat = SBV FPBFloat
+
 -- | A symbolic single-precision float
 type SFPSingle = SBV FPSingle
 
@@ -173,6 +177,9 @@
 -- Haskell strings. An 'SString' is a symbolic value of its own, of possibly arbitrary but finite length,
 -- and internally processed as one unit as opposed to a fixed-length list of characters.
 type SString = SBV String
+
+-- | A symbolic rational value.
+type SRational = SBV Rational
 
 -- | A symbolic list of items. Note that a symbolic list is /not/ a list of symbolic items,
 -- that is, it is not the case that @SList a = [a]@, unlike what one might expect following
diff --git a/Data/SBV/Core/Kind.hs b/Data/SBV/Core/Kind.hs
--- a/Data/SBV/Core/Kind.hs
+++ b/Data/SBV/Core/Kind.hs
@@ -66,6 +66,7 @@
           | KSet  Kind
           | KTuple [Kind]
           | KMaybe  Kind
+          | KRational
           | KEither Kind Kind
           deriving (Eq, Ord, G.Data)
 
@@ -89,6 +90,7 @@
   show (KTuple m)         = "(" ++ intercalate ", " (show <$> m) ++ ")"
   show (KMaybe k)         = "SMaybe "  ++ kindParen (showBaseKind k)
   show (KEither k1 k2)    = "SEither " ++ kindParen (showBaseKind k1) ++ " " ++ kindParen (showBaseKind k2)
+  show KRational          = "SRational"
 
 -- | A version of show for kinds that says Bool instead of SBool
 showBaseKind :: Kind -> String
@@ -104,6 +106,7 @@
         sh k@KFP{}            = noS (show k)
         sh k@KChar            = noS (show k)
         sh k@KString          = noS (show k)
+        sh KRational          = "Rational"
         sh (KList k)          = "[" ++ sh k ++ "]"
         sh (KSet k)           = "{" ++ sh k ++ "}"
         sh (KTuple ks)        = "(" ++ intercalate ", " (map sh ks) ++ ")"
@@ -143,6 +146,7 @@
 smtType (KUserSort s _) = s
 smtType (KTuple [])     = "SBVTuple0"
 smtType (KTuple kinds)  = "(SBVTuple" ++ show (length kinds) ++ " " ++ unwords (smtType <$> kinds) ++ ")"
+smtType KRational       = "SBVRational"
 smtType (KMaybe k)      = "(SBVMaybe " ++ smtType k ++ ")"
 smtType (KEither k1 k2) = "(SBVEither "  ++ smtType k1 ++ " " ++ smtType k2 ++ ")"
 
@@ -161,6 +165,7 @@
                     KFloat       -> True
                     KDouble      -> True
                     KFP{}        -> True
+                    KRational    -> True
                     KUserSort{}  -> False
                     KString      -> False
                     KChar        -> False
@@ -195,6 +200,7 @@
         -- below.
         badPrefixes = [ "SBool",   "SWord", "SInt", "SInteger", "SReal",  "SFloat", "SDouble"
                       , "SString", "SChar", "[",    "SSet",     "STuple", "SMaybe", "SEither"
+                      , "SRational"
                       ]
 
         dataType    = G.dataTypeOf a
@@ -215,6 +221,7 @@
   isReal      :: a -> Bool
   isFloat     :: a -> Bool
   isDouble    :: a -> Bool
+  isRational  :: a -> Bool
   isFP        :: a -> Bool
   isUnbounded :: a -> Bool
   isUserSort  :: a -> Bool
@@ -237,6 +244,7 @@
                   KFloat        -> error "SBV.HasKind.intSizeOf((S)Float)"
                   KDouble       -> error "SBV.HasKind.intSizeOf((S)Double)"
                   KFP{}         -> error "SBV.HasKind.intSizeOf((S)FP)"
+                  KRational     -> error "SBV.HasKind.intSizeOf((S)Rational)"
                   KUserSort s _ -> error $ "SBV.HasKind.intSizeOf: Uninterpreted sort: " ++ s
                   KString       -> error "SBV.HasKind.intSizeOf((S)Double)"
                   KChar         -> error "SBV.HasKind.intSizeOf((S)Char)"
@@ -264,6 +272,9 @@
   isFP            (kindOf -> KFP{})        = True
   isFP            _                        = False
 
+  isRational      (kindOf -> KRational{})  = True
+  isRational      _                        = False
+
   isUnbounded     (kindOf -> KUnbounded{}) = True
   isUnbounded     _                        = False
 
@@ -302,20 +313,21 @@
 instance HasKind a => HasKind (Proxy a) where
   kindOf _ = kindOf (undefined :: a)
 
-instance HasKind Bool    where kindOf _ = KBool
-instance HasKind Int8    where kindOf _ = KBounded True  8
-instance HasKind Word8   where kindOf _ = KBounded False 8
-instance HasKind Int16   where kindOf _ = KBounded True  16
-instance HasKind Word16  where kindOf _ = KBounded False 16
-instance HasKind Int32   where kindOf _ = KBounded True  32
-instance HasKind Word32  where kindOf _ = KBounded False 32
-instance HasKind Int64   where kindOf _ = KBounded True  64
-instance HasKind Word64  where kindOf _ = KBounded False 64
-instance HasKind Integer where kindOf _ = KUnbounded
-instance HasKind AlgReal where kindOf _ = KReal
-instance HasKind Float   where kindOf _ = KFloat
-instance HasKind Double  where kindOf _ = KDouble
-instance HasKind Char    where kindOf _ = KChar
+instance HasKind Bool     where kindOf _ = KBool
+instance HasKind Int8     where kindOf _ = KBounded True  8
+instance HasKind Word8    where kindOf _ = KBounded False 8
+instance HasKind Int16    where kindOf _ = KBounded True  16
+instance HasKind Word16   where kindOf _ = KBounded False 16
+instance HasKind Int32    where kindOf _ = KBounded True  32
+instance HasKind Word32   where kindOf _ = KBounded False 32
+instance HasKind Int64    where kindOf _ = KBounded True  64
+instance HasKind Word64   where kindOf _ = KBounded False 64
+instance HasKind Integer  where kindOf _ = KUnbounded
+instance HasKind AlgReal  where kindOf _ = KReal
+instance HasKind Rational where kindOf _ = KRational
+instance HasKind Float    where kindOf _ = KFloat
+instance HasKind Double   where kindOf _ = KDouble
+instance HasKind Char     where kindOf _ = KChar
 
 -- | Grab the bit-size from the proxy
 intOfProxy :: KnownNat n => Proxy n -> Int
@@ -332,6 +344,7 @@
 hasUninterpretedSorts KFloat                 = False
 hasUninterpretedSorts KDouble                = False
 hasUninterpretedSorts KFP{}                  = False
+hasUninterpretedSorts KRational              = False
 hasUninterpretedSorts KChar                  = False
 hasUninterpretedSorts KString                = False
 hasUninterpretedSorts (KList k)              = hasUninterpretedSorts k
@@ -389,6 +402,7 @@
 needsFlattening KFloat      = False
 needsFlattening KDouble     = False
 needsFlattening KFP{}       = False
+needsFlattening KRational   = False
 needsFlattening KChar       = False
 needsFlattening KString     = False
 needsFlattening KList{}     = True
diff --git a/Data/SBV/Core/Model.hs b/Data/SBV/Core/Model.hs
--- a/Data/SBV/Core/Model.hs
+++ b/Data/SBV/Core/Model.hs
@@ -31,9 +31,10 @@
   , sBool, sBool_, sBools, sWord8, sWord8_, sWord8s, sWord16, sWord16_, sWord16s, sWord32, sWord32_, sWord32s
   , sWord64, sWord64_, sWord64s, sInt8, sInt8_, sInt8s, sInt16, sInt16_, sInt16s, sInt32, sInt32_, sInt32s, sInt64, sInt64_
   , sInt64s, sInteger, sInteger_, sIntegers, sReal, sReal_, sReals, sFloat, sFloat_, sFloats, sDouble, sDouble_, sDoubles
-  , sFPHalf, sFPHalf_, sFPHalfs, sFPSingle, sFPSingle_, sFPSingles, sFPDouble, sFPDouble_, sFPDoubles, sFPQuad, sFPQuad_, sFPQuads
+  , sFPHalf, sFPHalf_, sFPHalfs, sFPBFloat, sFPBFloat_, sFPBFloats, sFPSingle, sFPSingle_, sFPSingles, sFPDouble, sFPDouble_, sFPDoubles, sFPQuad, sFPQuad_, sFPQuads
   , sFloatingPoint, sFloatingPoint_, sFloatingPoints
   , sChar, sChar_, sChars, sString, sString_, sStrings, sList, sList_, sLists
+  , sRational, sRational_, sRationals
   , SymTuple, sTuple, sTuple_, sTuples
   , sEither, sEither_, sEithers, sMaybe, sMaybe_, sMaybes
   , sSet, sSet_, sSets
@@ -165,6 +166,12 @@
   literal  = SBV . SVal KUnbounded . Left . mkConstCV KUnbounded
   fromCV   = genFromCV
 
+instance SymVal Rational where
+  mkSymVal                    = genMkSymVar KRational
+  literal                     = SBV . SVal KRational  . Left . CV KRational . CRational
+  fromCV (CV _ (CRational r)) = r
+  fromCV c                    = error $ "SymVal.Rational: Unexpected non-rational value: " ++ show c
+
 instance SymVal AlgReal where
   mkSymVal                   = genMkSymVar KReal
   literal                    = SBV . SVal KReal . Left . CV KReal . CAlgReal
@@ -531,6 +538,18 @@
 sFPHalfs :: [String] -> Symbolic [SFPHalf]
 sFPHalfs = symbolics
 
+-- | Generalization of 'Data.SBV.sFPBFloat'
+sFPBFloat :: String -> Symbolic SFPBFloat
+sFPBFloat = symbolic
+
+-- | Generalization of 'Data.SBV.sFPBFloat_'
+sFPBFloat_ :: Symbolic SFPBFloat
+sFPBFloat_ = free_
+
+-- | Generalization of 'Data.SBV.sFPBFloats'
+sFPBFloats :: [String] -> Symbolic [SFPBFloat]
+sFPBFloats = symbolics
+
 -- | Generalization of 'Data.SBV.sFPSingle'
 sFPSingle :: String -> Symbolic SFPSingle
 sFPSingle = symbolic
@@ -638,6 +657,18 @@
 sTuples :: (SymTuple tup, SymVal tup, MonadSymbolic m) => [String] -> m [SBV tup]
 sTuples = symbolics
 
+-- | Generalization of 'Data.SBV.sRational'
+sRational :: MonadSymbolic m => String -> m SRational
+sRational = symbolic
+
+-- | Generalization of 'Data.SBV.sRational_'
+sRational_ :: MonadSymbolic m => m SRational
+sRational_ = free_
+
+-- | Generalization of 'Data.SBV.sRationals'
+sRationals :: MonadSymbolic m => [String] -> m [SRational]
+sRationals = symbolics
+
 -- | Generalization of 'Data.SBV.sEither'
 sEither :: (SymVal a, SymVal b, MonadSymbolic m) => String -> m (SEither a b)
 sEither = symbolic
@@ -962,6 +993,7 @@
       KUserSort  {} -> True
       KFloat        -> True
       KDouble       -> True
+      KRational  {} -> True
       KFP        {} -> True
       KChar         -> True
       KString       -> True
@@ -1365,6 +1397,7 @@
                       KDouble            -> False
                       KFP{}              -> False
                       KReal              -> True
+                      KRational          -> True
                       -- Following cases should not happen since these types should *not* be instances of Fractional
                       k@KBounded{}  -> error $ "Unexpected Fractional case for: " ++ show k
                       k@KUnbounded  -> error $ "Unexpected Fractional case for: " ++ show k
diff --git a/Data/SBV/Core/Operations.hs b/Data/SBV/Core/Operations.hs
--- a/Data/SBV/Core/Operations.hs
+++ b/Data/SBV/Core/Operations.hs
@@ -154,7 +154,7 @@
 svPlus x y
   | isConcreteZero x = y
   | isConcreteZero y = x
-  | True             = liftSym2 (mkSymOp Plus) [rationalCheck] (+) (+) (+) (+) (+) x y
+  | True             = liftSym2 (mkSymOp Plus) [rationalCheck] (+) (+) (+) (+) (+) (+) x y
 
 -- | Multiplication.
 svTimes :: SVal -> SVal -> SVal
@@ -163,25 +163,25 @@
   | isConcreteZero y = y
   | isConcreteOne x  = y
   | isConcreteOne y  = x
-  | True             = liftSym2 (mkSymOp Times) [rationalCheck] (*) (*) (*) (*) (*) x y
+  | True             = liftSym2 (mkSymOp Times) [rationalCheck] (*) (*) (*) (*) (*) (*) x y
 
 -- | Subtraction.
 svMinus :: SVal -> SVal -> SVal
 svMinus x y
   | isConcreteZero y = x
-  | True             = liftSym2 (mkSymOp Minus) [rationalCheck] (-) (-) (-) (-) (-) x y
+  | True             = liftSym2 (mkSymOp Minus) [rationalCheck] (-) (-) (-) (-) (-) (-) x y
 
 -- | Unary minus. We handle arbitrary-FP's specially here, just for the negated literals.
 svUNeg :: SVal -> SVal
-svUNeg = liftSym1 (mkSymOp1 UNeg) negate negate negate negate negate
+svUNeg = liftSym1 (mkSymOp1 UNeg) negate negate negate negate negate negate
 
 -- | Absolute value.
 svAbs :: SVal -> SVal
-svAbs = liftSym1 (mkSymOp1 Abs) abs abs abs abs abs
+svAbs = liftSym1 (mkSymOp1 Abs) abs abs abs abs abs abs
 
 -- | Division.
 svDivide :: SVal -> SVal -> SVal
-svDivide = liftSym2 (mkSymOp Quot) [rationalCheck] (/) idiv (/) (/) (/)
+svDivide = liftSym2 (mkSymOp Quot) [rationalCheck] (/) idiv (/) (/) (/) (/)
    where idiv x 0 = x
          idiv x y = x `div` y
 
@@ -253,7 +253,7 @@
   | isConcreteZero y = svInteger (kindOf x) 0
   | isConcreteOne  y = x
   | True             = liftSym2 (mkSymOp Quot) [nonzeroCheck]
-                                (noReal "quot") quot' (noFloat "quot") (noDouble "quot") (noFP "quot") x y
+                                (noReal "quot") quot' (noFloat "quot") (noDouble "quot") (noFP "quot") (noRat "quot") x y
   where
     quot' a b | kindOf x == KUnbounded = div a (abs b) * signum b
               | otherwise              = quot a b
@@ -270,7 +270,7 @@
   | isConcreteZero y = x
   | isConcreteOne  y = svInteger (kindOf x) 0
   | True             = liftSym2 (mkSymOp Rem) [nonzeroCheck]
-                                (noReal "rem") rem' (noFloat "rem") (noDouble "rem") (noFP "rem") x y
+                                (noReal "rem") rem' (noFloat "rem") (noDouble "rem") (noFP "rem") (noRat "rem") x y
   where
     rem' a b | kindOf x == KUnbounded = mod a (abs b)
              | otherwise              = rem a b
@@ -380,7 +380,7 @@
   | isConcreteOnes x = y
   | isConcreteZero y = y
   | isConcreteOnes y = x
-  | True             = liftSym2 (mkSymOpSC opt And) [] (noReal ".&.") (.&.) (noFloat ".&.") (noDouble ".&.") (noFP ".&.") x y
+  | True             = liftSym2 (mkSymOpSC opt And) [] (noReal ".&.") (.&.) (noFloat ".&.") (noDouble ".&.") (noFP ".&.") (noRat ".&") x y
   where opt a b
           | a == falseSV || b == falseSV = Just falseSV
           | a == trueSV                  = Just b
@@ -395,7 +395,7 @@
   | isConcreteZero y = x
   | isConcreteOnes y = y
   | True             = liftSym2 (mkSymOpSC opt Or) []
-                       (noReal ".|.") (.|.) (noFloat ".|.") (noDouble ".|.") (noFP ".|.") x y
+                       (noReal ".|.") (.|.) (noFloat ".|.") (noDouble ".|.") (noFP ".|.") (noRat ".|.") x y
   where opt a b
           | a == trueSV || b == trueSV = Just trueSV
           | a == falseSV               = Just b
@@ -410,7 +410,7 @@
   | isConcreteZero y = x
   | isConcreteOnes y = svNot x
   | True             = liftSym2 (mkSymOpSC opt XOr) []
-                       (noReal "xor") xor (noFloat "xor") (noDouble "xor") (noFP "xor") x y
+                       (noReal "xor") xor (noFloat "xor") (noDouble "xor") (noFP "xor") (noRat "xor") x y
   where opt a b
           | a == b && swKind a == KBool = Just falseSV
           | a == falseSV                = Just b
@@ -421,7 +421,7 @@
 svNot :: SVal -> SVal
 svNot = liftSym1 (mkSymOp1SC opt Not)
                  (noRealUnary "complement") complement
-                 (noFloatUnary "complement") (noDoubleUnary "complement") (noFPUnary "complement")
+                 (noFloatUnary "complement") (noDoubleUnary "complement") (noFPUnary "complement") (noRatUnary "complement")
   where opt a
           | a == falseSV = Just trueSV
           | a == trueSV  = Just falseSV
@@ -474,7 +474,7 @@
   = case kindOf x of
            KBounded _ sz -> liftSym1 (mkSymOp1 (Rol (i `mod` sz)))
                                      (noRealUnary "rotateL") (rot True sz i)
-                                     (noFloatUnary "rotateL") (noDoubleUnary "rotateL") (noFPUnary "rotateL") x
+                                     (noFloatUnary "rotateL") (noDoubleUnary "rotateL") (noFPUnary "rotateL") (noRatUnary "rotateL") x
            _ -> svShl x i   -- for unbounded Integers, rotateL is the same as shiftL in Haskell
 
 -- | Rotate-right, by a constant.
@@ -489,7 +489,7 @@
   = case kindOf x of
       KBounded _ sz -> liftSym1 (mkSymOp1 (Ror (i `mod` sz)))
                                 (noRealUnary "rotateR") (rot False sz i)
-                                (noFloatUnary "rotateR") (noDoubleUnary "rotateR") (noFPUnary "rotateR") x
+                                (noFloatUnary "rotateR") (noDoubleUnary "rotateR") (noFPUnary "rotateR") (noRatUnary "rotateR") x
       _ -> svShr x i   -- for unbounded integers, rotateR is the same as shiftR in Haskell
 
 -- | Generic rotation. Since the underlying representation is just Integers, rotations has to be
@@ -1265,9 +1265,9 @@
 noStringLift2 :: String -> String -> a
 noStringLift2 x y = error $ "Unexpected binary operation called on strings: " ++ show (x, y)
 
-liftSym1 :: (State -> Kind -> SV -> IO SV) -> (AlgReal -> AlgReal) -> (Integer -> Integer) -> (Float -> Float) -> (Double -> Double) -> (FP -> FP) -> SVal -> SVal
-liftSym1 _   opCR opCI opCF opCD opFP  (SVal k (Left a)) = SVal k . Left  $! mapCV opCR opCI opCF opCD opFP noCharLift noStringLift noUnint a
-liftSym1 opS _    _    _    _    _   a@(SVal k _)        = SVal k $ Right $ cache c
+liftSym1 :: (State -> Kind -> SV -> IO SV) -> (AlgReal -> AlgReal) -> (Integer -> Integer) -> (Float -> Float) -> (Double -> Double) -> (FP -> FP) ->(Rational -> Rational) -> SVal -> SVal
+liftSym1 _   opCR opCI opCF opCD opFP opRA   (SVal k (Left a)) = SVal k . Left  $! mapCV opCR opCI opCF opCD opFP opRA noCharLift noStringLift noUnint a
+liftSym1 opS _    _    _    _    _    _    a@(SVal k _)        = SVal k $ Right $ cache c
    where c st = do sva <- svToSV st a
                    opS st k sva
 
@@ -1324,15 +1324,16 @@
                   opS st k sw1 sw2
 
 liftSym2 :: (State -> Kind -> SV -> SV -> IO SV)
-         -> [CV      -> CV      -> Bool]
-         -> (AlgReal -> AlgReal -> AlgReal)
-         -> (Integer -> Integer -> Integer)
-         -> (Float   -> Float   -> Float)
-         -> (Double  -> Double  -> Double)
-         -> (FP      -> FP      -> FP)
-         -> SVal     -> SVal    -> SVal
-liftSym2 _   okCV opCR opCI opCF opCD opFP  (SVal k (Left a)) (SVal _ (Left b)) | and [f a b | f <- okCV] = SVal k . Left  $! mapCV2 opCR opCI opCF opCD opFP noCharLift2 noStringLift2 noUnint2 a b
-liftSym2 opS _    _    _    _    _    _   a@(SVal k _)        b                                           = SVal k $ Right $  liftSV2 opS k a b
+         -> [CV       -> CV      -> Bool]
+         -> (AlgReal  -> AlgReal -> AlgReal)
+         -> (Integer  -> Integer -> Integer)
+         -> (Float    -> Float   -> Float)
+         -> (Double   -> Double  -> Double)
+         -> (FP       -> FP      -> FP)
+         -> (Rational -> Rational-> Rational)
+         -> SVal      -> SVal    -> SVal
+liftSym2 _   okCV opCR opCI opCF opCD opFP opRA (SVal k (Left a)) (SVal _ (Left b)) | and [f a b | f <- okCV] = SVal k . Left  $! mapCV2 opCR opCI opCF opCD opFP opRA noCharLift2 noStringLift2 noUnint2 a b
+liftSym2 opS _    _    _    _    _    _  _      a@(SVal k _)      b                                           = SVal k $ Right $  liftSV2 opS k a b
 
 liftSym2B :: (State -> Kind -> SV -> SV -> IO SV)
           -> (CV                  -> CV                  -> Bool)
@@ -1456,6 +1457,9 @@
 noFP :: String -> FP -> FP -> FP
 noFP o a b = error $ "SBV.FPR." ++ o ++ ": Unexpected arguments: " ++ show (a, b)
 
+noRat:: String -> Rational -> Rational -> Rational
+noRat o a b = error $ "SBV.Rational." ++ o ++ ": Unexpected arguments: " ++ show (a, b)
+
 noRealUnary :: String -> AlgReal -> AlgReal
 noRealUnary o a = error $ "SBV.AlgReal." ++ o ++ ": Unexpected argument: " ++ show a
 
@@ -1465,9 +1469,11 @@
 noDoubleUnary :: String -> Double -> Double
 noDoubleUnary o a = error $ "SBV.Double." ++ o ++ ": Unexpected argument: " ++ show a
 
-
 noFPUnary :: String -> FP -> FP
 noFPUnary o a = error $ "SBV.FPR." ++ o ++ ": Unexpected argument: " ++ show a
+
+noRatUnary :: String -> Rational -> Rational
+noRatUnary o a = error $ "SBV.Rational." ++ o ++ ": Unexpected argument: " ++ show a
 
 -- | Given a composite structure, figure out how to compare for less than
 svStructuralLessThan :: SVal -> SVal -> SVal
diff --git a/Data/SBV/Core/SizedFloats.hs b/Data/SBV/Core/SizedFloats.hs
--- a/Data/SBV/Core/SizedFloats.hs
+++ b/Data/SBV/Core/SizedFloats.hs
@@ -20,7 +20,7 @@
 
 module Data.SBV.Core.SizedFloats (
         -- * Type-sized floats
-          FloatingPoint(..), FP(..), FPHalf, FPSingle, FPDouble, FPQuad
+          FloatingPoint(..), FP(..), FPHalf, FPBFloat, FPSingle, FPDouble, FPQuad
 
         -- * Constructing values
         , fpFromRawRep, fpNaN, fpInf, fpZero
@@ -54,16 +54,19 @@
 newtype FloatingPoint (eb :: Nat) (sb :: Nat) = FloatingPoint FP
                                               deriving (Eq, Ord)
 
--- | Abbreviation for IEEE half precision float, bit width 16.
+-- | Abbreviation for IEEE half precision float, bit width 16 = 5 + 11.
 type FPHalf = FloatingPoint 5 11
 
--- | Abbreviation for IEEE single precision float, bit width 32.
+-- | Abbreviation for brain-float precision float, bit width 16 = 8 + 8.
+type FPBFloat = FloatingPoint 8 8
+
+-- | Abbreviation for IEEE single precision float, bit width 32 = 8 + 24.
 type FPSingle = FloatingPoint 8 24
 
--- | Abbreviation for IEEE double precision float, bit width 64.
+-- | Abbreviation for IEEE double precision float, bit width 64 = 11 + 53.
 type FPDouble = FloatingPoint 11 53
 
--- | Abbreviation for IEEE quadruble precision float, bit width 128.
+-- | Abbreviation for IEEE quadruble precision float, bit width 128 = 15 + 113.
 type FPQuad = FloatingPoint 15 113
 
 -- | Show instance for Floats. By default we print in base 10, with standard scientific notation.
@@ -100,10 +103,15 @@
           | withPrefix = BF.addPrefix <> opts
           | True       = opts
 
+        -- In base 10, exponent starts with 'e'. Otherwise (2, 8, 16) it starts with 'p'
+        expChar = if b == 10 then 'e' else 'p'
+
         trimZeros s
-          | '.' `elem` s = reverse $ case dropWhile (== '0') $ reverse s of
-                                       res@('.':_) -> '0' : res
-                                       res         -> res
+          | '.' `elem` s = case span (/= expChar) s of
+                            (pre, post) -> let pre' = reverse $ case dropWhile (== '0') $ reverse pre of
+                                                                  res@('.':_) -> '0' : res
+                                                                  res         -> res
+                                           in pre' ++ post
           | True         = s
 
 -- | Default options for BF options.
@@ -339,5 +347,5 @@
 
 -- | Convert from a IEEE double.
 fpFromDouble :: Int -> Int -> Double -> FP
-fpFromDouble 11 54 d = FP 11 54 $ BF.bfFromDouble d
+fpFromDouble 11 53 d = FP 11 54 $ BF.bfFromDouble d
 fpFromDouble eb sb d = error $ "SBV.fprFromDouble: Unexpected input: " ++ show (eb, sb, d)
diff --git a/Data/SBV/Core/Symbolic.hs b/Data/SBV/Core/Symbolic.hs
--- a/Data/SBV/Core/Symbolic.hs
+++ b/Data/SBV/Core/Symbolic.hs
@@ -203,6 +203,7 @@
         | EitherConstructor Kind Kind Bool      -- Construct a sum; False: left, True: right
         | EitherIs Kind Kind Bool               -- Either branch tester; False: left, True: right
         | EitherAccess Bool                     -- Either branch access; False: left, True: right
+        | RationalConstructor                   -- Construct a rational. Note that there's no access to numerator or denumerator, since we cannot store rationals in canonical form
         | MaybeConstructor Kind Bool            -- Construct a maybe value; False: Nothing, True: Just
         | MaybeIs Kind Bool                     -- Maybe tester; False: nothing, True: just
         | MaybeAccess                           -- Maybe branch access; grab the contents of the just
@@ -531,6 +532,7 @@
   show (EitherIs          k1 k2  True ) = "(_ is (right_SBVEither (" ++ show k2 ++ ") " ++ show (KEither k1 k2) ++ "))"
   show (EitherAccess             False) = "get_left_SBVEither"
   show (EitherAccess             True ) = "get_right_SBVEither"
+  show RationalConstructor              = "SBV.Rational"
   show (MaybeConstructor k False)       = "(_ nothing_SBVMaybe " ++ show (KMaybe k) ++ ")"
   show (MaybeConstructor k True)        = "(_ just_SBVMaybe "    ++ show (KMaybe k) ++ ")"
   show (MaybeIs          k False)       = "(_ is (nothing_SBVMaybe () "              ++ show (KMaybe k) ++ "))"
@@ -610,7 +612,7 @@
 
 -- | 'NamedSymVar' pairs symbolic values and user given/automatically generated names
 data NamedSymVar = NamedSymVar !SV !Name
-                 deriving (Show,Generic)
+                 deriving (Show, Generic)
 
 -- | For comparison purposes, we simply use the SV and ignore the name
 instance Eq NamedSymVar where
@@ -988,7 +990,6 @@
         finalIncState <- readIORef (rIncState st)
         return (finalIncState, r)
 
-
 -- | User defined, with proper quantifiers
 type UserInputs = S.Seq (Quantifier, NamedSymVar)
 
@@ -1360,6 +1361,7 @@
          KFloat    {}    -> return ()
          KDouble   {}    -> return ()
          KFP       {}    -> return ()
+         KRational {}    -> return ()
          KChar     {}    -> return ()
          KString   {}    -> return ()
          KList     ek    -> registerKind st ek
diff --git a/Data/SBV/Rational.hs b/Data/SBV/Rational.hs
new file mode 100644
--- /dev/null
+++ b/Data/SBV/Rational.hs
@@ -0,0 +1,40 @@
+-----------------------------------------------------------------------------
+-- |
+-- Module    : Data.SBV.Rational
+-- Copyright : (c) Levent Erkok
+-- License   : BSD3
+-- Maintainer: erkokl@gmail.com
+-- Stability : experimental
+--
+-- Symbolic rationals, corresponds to Haskell's 'Rational' type
+-----------------------------------------------------------------------------
+
+{-# OPTIONS_GHC -Wall -Werror #-}
+
+module Data.SBV.Rational (
+    -- * Constructing rationals
+      (.%)
+  ) where
+
+import qualified Data.Ratio as R
+
+import Data.SBV.Core.Data
+import Data.SBV.Core.Model () -- instances only
+
+infixl 7 .%
+
+-- | Construct a symbolic rational from a given numerator and denominator. Note that
+-- it is not possible to deconstruct a rational by taking numerator and denominator
+-- fields, since we do not represent them canonically. (This is due to the fact that
+-- SMTLib has no functions to compute the GCD. One can use the maximization engine
+-- to compute the GCD of numbers, but not as a function.)
+(.%) :: SInteger -> SInteger -> SRational
+top .% bot
+ | Just t <- unliteral top
+ , Just b <- unliteral bot
+ = literal $ t R.% b
+ | True
+ = SBV $ SVal KRational $ Right $ cache res
+ where res st = do t <- sbvToSV st top
+                   b <- sbvToSV st bot
+                   newExpr st KRational $ SBVApp RationalConstructor [t, b]
diff --git a/Data/SBV/RegExp.hs b/Data/SBV/RegExp.hs
--- a/Data/SBV/RegExp.hs
+++ b/Data/SBV/RegExp.hs
@@ -84,7 +84,7 @@
 -- >>> let phone = pre * "-" * post
 -- >>> sat $ \s -> (s :: SString) `match` phone
 -- Satisfiable. Model:
---   s0 = "388-3868" :: String
+--   s0 = "386-3868" :: String
 class RegExpMatchable a where
    -- | @`match` s r@ checks whether @s@ is in the language generated by @r@.
    match :: a -> RegExp -> SBool
diff --git a/Data/SBV/SMT/SMTLib2.hs b/Data/SBV/SMT/SMTLib2.hs
--- a/Data/SBV/SMT/SMTLib2.hs
+++ b/Data/SBV/SMT/SMTLib2.hs
@@ -63,6 +63,7 @@
         hasTuples      = not . null $ tupleArities
         hasEither      = any isEither kindInfo
         hasMaybe       = any isMaybe  kindInfo
+        hasRational    = any isRational kindInfo
         rm             = roundingMode cfg
         solverCaps     = capabilities (solver cfg)
 
@@ -112,6 +113,7 @@
 
            -- Things that require ALL
            | hasInteger            = setAll "has unbounded values"
+           | hasRational           = setAll "has rational values"
            | hasReal               = setAll "has algebraic reals"
            | not (null trueUSorts) = setAll "has user-defined sorts"
            | hasNonBVArrays        = setAll "has non-bitvector arrays"
@@ -178,8 +180,9 @@
              ++ [ "; --- tuples ---" ]
              ++ concatMap declTuple tupleArities
              ++ [ "; --- sums ---" ]
-             ++ (if containsSum   kindInfo then declSum   else [])
-             ++ (if containsMaybe kindInfo then declMaybe else [])
+             ++ (if containsSum       kindInfo then declSum       else [])
+             ++ (if containsMaybe     kindInfo then declMaybe     else [])
+             ++ (if containsRationals kindInfo then declRationals else [])
              ++ [ "; --- literal constants ---" ]
              ++ concatMap (declConst cfg) consts
              ++ [ "; --- skolem constants ---" ]
@@ -388,6 +391,10 @@
 containsMaybe :: Set Kind -> Bool
 containsMaybe = not . Set.null . Set.filter isMaybe
 
+-- | Is @Rational@ being used?
+containsRationals :: Set Kind -> Bool
+containsRationals = not . Set.null . Set.filter isRational
+
 declSum :: [String]
 declSum = [ "(declare-datatypes ((SBVEither 2)) ((par (T1 T2)"
           , "                                    ((left_SBVEither  (get_left_SBVEither  T1))"
@@ -400,6 +407,56 @@
             , "                                     (just_SBVMaybe (get_just_SBVMaybe T))))))"
             ]
 
+-- Internally, we do *not* keep the rationals in reduced form! So, the boolean operators explicitly do the math
+-- to make sure equivalent values are treated correctly.
+declRationals :: [String]
+declRationals = [ "(declare-datatype SBVRational ((SBV.Rational (sbv.rat.numerator Int) (sbv.rat.denominator Int))))"
+                , ""
+                , "(define-fun sbv.rat.eq ((x SBVRational) (y SBVRational)) Bool"
+                , "   (= (* (sbv.rat.numerator   x) (sbv.rat.denominator y))"
+                , "      (* (sbv.rat.denominator x) (sbv.rat.numerator   y)))"
+                , ")"
+                , ""
+                , "(define-fun sbv.rat.notEq ((x SBVRational) (y SBVRational)) Bool"
+                , "   (not (sbv.rat.eq x y))"
+                , ")"
+                , ""
+                , "(define-fun sbv.rat.lt ((x SBVRational) (y SBVRational)) Bool"
+                , "   (<  (* (sbv.rat.numerator   x) (sbv.rat.denominator y))"
+                , "       (* (sbv.rat.denominator x) (sbv.rat.numerator   y)))"
+                , ")"
+                , ""
+                , "(define-fun sbv.rat.leq ((x SBVRational) (y SBVRational)) Bool"
+                , "   (<= (* (sbv.rat.numerator   x) (sbv.rat.denominator y))"
+                , "       (* (sbv.rat.denominator x) (sbv.rat.numerator   y)))"
+                , ")"
+                , ""
+                , "(define-fun sbv.rat.plus ((x SBVRational) (y SBVRational)) SBVRational"
+                , "   (SBV.Rational (+ (* (sbv.rat.numerator   x) (sbv.rat.denominator y))"
+                , "                    (* (sbv.rat.denominator x) (sbv.rat.numerator   y)))"
+                , "                 (* (sbv.rat.denominator x) (sbv.rat.denominator y)))"
+                , ")"
+                , ""
+                , "(define-fun sbv.rat.minus ((x SBVRational) (y SBVRational)) SBVRational"
+                , "   (SBV.Rational (- (* (sbv.rat.numerator   x) (sbv.rat.denominator y))"
+                , "                    (* (sbv.rat.denominator x) (sbv.rat.numerator   y)))"
+                , "                 (* (sbv.rat.denominator x) (sbv.rat.denominator y)))"
+                , ")"
+                , ""
+                , "(define-fun sbv.rat.times ((x SBVRational) (y SBVRational)) SBVRational"
+                , "   (SBV.Rational (* (sbv.rat.numerator   x) (sbv.rat.numerator y))"
+                , "                 (* (sbv.rat.denominator x) (sbv.rat.denominator y)))"
+                , ")"
+                , ""
+                , "(define-fun sbv.rat.uneg ((x SBVRational)) SBVRational"
+                , "   (SBV.Rational (* (- 1) (sbv.rat.numerator x)) (sbv.rat.denominator x))"
+                , ")"
+                , ""
+                , "(define-fun sbv.rat.abs ((x SBVRational)) SBVRational"
+                , "   (SBV.Rational (abs (sbv.rat.numerator x)) (sbv.rat.denominator x))"
+                , ")"
+                ]
+
 -- | Convert in a query context.
 -- NB. We do not store everything in @newKs@ below, but only what we need
 -- to do as an extra in the incremental context. See `Data.SBV.Core.Symbolic.registerKind`
@@ -648,6 +705,7 @@
 
         bvOp     = all isBounded   arguments
         intOp    = any isUnbounded arguments
+        ratOp    = any isRational  arguments
         realOp   = any isReal      arguments
         fpOp     = any (\a -> isDouble a || isFloat a || isFP a) arguments
         boolOp   = all isBoolean   arguments
@@ -776,6 +834,7 @@
                               KFloat        -> error "SBV.SMT.SMTLib2.cvtExp: unexpected float valued index"
                               KDouble       -> error "SBV.SMT.SMTLib2.cvtExp: unexpected double valued index"
                               KFP{}         -> error "SBV.SMT.SMTLib2.cvtExp: unexpected arbitrary float valued index"
+                              KRational{}   -> error "SBV.SMT.SMTLib2.cvtExp: unexpected rational valued index"
                               KChar         -> error "SBV.SMT.SMTLib2.cvtExp: unexpected char valued index"
                               KString       -> error "SBV.SMT.SMTLib2.cvtExp: unexpected string valued index"
                               KList k       -> error $ "SBV.SMT.SMTLib2.cvtExp: unexpected list valued: " ++ show k
@@ -797,8 +856,9 @@
                                 KUnbounded    -> ("<", "<=")
                                 KReal         -> ("<", "<=")
                                 KFloat        -> ("fp.lt", "fp.leq")
-                                KDouble       -> ("fp.lt", "fp.geq")
-                                KFP{}         -> ("fp.lt", "fp.geq")
+                                KDouble       -> ("fp.lt", "fp.leq")
+                                KRational     -> ("sbv.rat.lt", "sbv.rat.leq")
+                                KFP{}         -> ("fp.lt", "fp.leq")
                                 KChar         -> error "SBV.SMT.SMTLib2.cvtExp: unexpected string valued index"
                                 KString       -> error "SBV.SMT.SMTLib2.cvtExp: unexpected string valued index"
                                 KList k       -> error $ "SBV.SMT.SMTLib2.cvtExp: unexpected sequence valued index: " ++ show k
@@ -896,6 +956,8 @@
         sh (SBVApp (EitherAccess            False) [arg]) = "(get_left_SBVEither "  ++ ssv arg ++ ")"
         sh (SBVApp (EitherAccess            True ) [arg]) = "(get_right_SBVEither " ++ ssv arg ++ ")"
 
+        sh (SBVApp  RationalConstructor    [t, b]) = "(SBV.Rational " ++ ssv t ++ " " ++ ssv b ++ ")"
+
         sh (SBVApp (MaybeConstructor k False) [])    =       dtConstructor "nothing_SBVMaybe" []    (KMaybe k)
         sh (SBVApp (MaybeConstructor k True)  [arg]) =       dtConstructor "just_SBVMaybe"    [arg] (KMaybe k)
         sh (SBVApp (MaybeIs          k False) [arg]) = '(' : dtAccessor    "nothing_SBVMaybe" []    (KMaybe k) ++ " " ++ ssv arg ++ ")"
@@ -911,6 +973,8 @@
           = f (any hasSign args) (map ssv args)
           | realOp, Just f <- lookup op smtOpRealTable
           = f (any hasSign args) (map ssv args)
+          | ratOp, Just f <- lookup op ratOpTable
+          = f (map ssv args)
           | fpOp, Just f <- lookup op smtOpFloatDoubleTable
           = f (any hasSign args) (map ssv args)
           | charOp || stringOp, Just f <- lookup op smtStringTable
@@ -983,6 +1047,25 @@
                                     , (GreaterEq,     lift2Cmp  ">=" "fp.geq")
                                     ]
 
+                ratOpTable = [ (Plus,        lift2Rat "sbv.rat.plus")
+                             , (Minus,       lift2Rat "sbv.rat.minus")
+                             , (Times,       lift2Rat "sbv.rat.times")
+                             , (UNeg,        liftRat  "sbv.rat.uneg")
+                             , (Abs,         liftRat  "sbv.rat.abs")
+                             , (Equal,       lift2Rat "sbv.rat.eq")
+                             , (NotEqual,    lift2Rat "sbv.rat.notEq")
+                             , (LessThan,    lift2Rat "sbv.rat.lt")
+                             , (GreaterThan, lift2Rat "sbv.rat.lt" . swap)
+                             , (LessEq,      lift2Rat "sbv.rat.leq")
+                             , (GreaterEq,   lift2Rat "sbv.rat.leq" . swap)
+                             ]
+                        where lift2Rat o [x, y] = "(" ++ o ++ " " ++ x ++ " " ++ y ++ ")"
+                              lift2Rat o sbvs   = error $ "SBV.SMTLib2.sh.lift2Rat: Unexpected arguments: "   ++ show (o, sbvs)
+                              liftRat  o [x]    = "(" ++ o ++ " " ++ x ++ ")"
+                              liftRat  o sbvs   = error $ "SBV.SMTLib2.sh.lift2Rat: Unexpected arguments: "   ++ show (o, sbvs)
+                              swap [x, y]       = [y, x]
+                              swap sbvs         = error $ "SBV.SMTLib2.sh.swap: Unexpected arguments: "   ++ show sbvs
+
                 -- equality and comparisons are the only thing that works on uninterpreted sorts and pretty much everything else
                 uninterpretedTable = [ (Equal,       lift2S "="        "="        True)
                                      , (NotEqual,    liftNS "distinct" "distinct" True)
@@ -993,7 +1076,6 @@
                                      ]
 
                 -- For strings, equality and comparisons are the only operators
-                -- TODO: The string comparison operators will most likely change with the new theory!
                 smtStringTable = [ (Equal,       lift2S "="        "="        True)
                                  , (NotEqual,    liftNS "distinct" "distinct" True)
                                  , (LessThan,    stringCmp False "str.<")
@@ -1015,6 +1097,9 @@
 declareFun :: SV -> SBVType -> Maybe String -> [String]
 declareFun = declareName . show
 
+-- If we have a char, we have to make sure it's and SMTLib string of length exactly one
+-- If we have a rational, we have to make sure the denominator is > 0
+-- Otherwise, we just declare the name
 declareName :: String -> SBVType -> Maybe String -> [String]
 declareName s t@(SBVType inputKS) mbCmnt = decl : restrict
   where decl        = "(declare-fun " ++ s ++ " " ++ cvtType t ++ ")" ++ maybe "" (" ; " ++) mbCmnt
@@ -1023,10 +1108,10 @@
                           [] -> error $ "SBV.declareName: Unexpected empty type for: " ++ show s
                           _  -> (init inputKS, last inputKS)
 
-        -- Does the kind KChar *not* occur in the kind anywhere?
-        charFree k = null [() | KChar <- G.universe k]
-        noChars    = charFree result
-        needsQuant = not $ null args
+        -- Does the kind KChar and KRational *not* occur in the kind anywhere?
+        charRatFree k = null $ [() | KChar <- G.universe k] ++ [() | KRational <- G.universe k]
+        noCharOrRat   = charRatFree result
+        needsQuant    = not $ null args
 
         resultVar | needsQuant = "result"
                   | True       = s
@@ -1035,51 +1120,54 @@
         argTList  = ["(" ++ a ++ " " ++ smtType k ++ ")" | (a, k) <- zip argList args]
         resultExp = "(" ++ s ++ " " ++ unwords argList ++ ")"
 
-        restrict | noChars    = []
-                 | needsQuant =    [               "(assert (forall (" ++ unwords argTList ++ ")"
-                                   ,               "                (let ((" ++ resultVar ++ " " ++ resultExp ++ "))"
-                                   ]
-                                ++ (case constraints of
-                                      []     ->  [ "                     true"]
-                                      [x]    ->  [ "                     " ++ x]
-                                      (x:xs) ->  ( "                     (and " ++ x)
-                                              :  [ "                          " ++ c | c <- xs]
-                                              ++ [ "                     )"])
-                                ++ [        "                )))"]
-                 | True       = case constraints of
-                                 []     -> []
-                                 [x]    -> ["(assert " ++ x ++ ")"]
-                                 (x:xs) -> ( "(assert (and " ++ x)
-                                        :  [ "             " ++ c | c <- xs]
-                                        ++ [ "        ))"]
+        restrict | noCharOrRat = []
+                 | needsQuant  =    [               "(assert (forall (" ++ unwords argTList ++ ")"
+                                    ,               "                (let ((" ++ resultVar ++ " " ++ resultExp ++ "))"
+                                    ]
+                                 ++ (case constraints of
+                                       []     ->  [ "                     true"]
+                                       [x]    ->  [ "                     " ++ x]
+                                       (x:xs) ->  ( "                     (and " ++ x)
+                                               :  [ "                          " ++ c | c <- xs]
+                                               ++ [ "                     )"])
+                                 ++ [        "                )))"]
+                 | True        = case constraints of
+                                  []     -> []
+                                  [x]    -> ["(assert " ++ x ++ ")"]
+                                  (x:xs) -> ( "(assert (and " ++ x)
+                                         :  [ "             " ++ c | c <- xs]
+                                         ++ [ "        ))"]
 
-        constraints = walk 0 resultVar (\nm -> "(= 1 (str.len " ++ nm ++ "))") result
+        constraints = walk 0 resultVar cstr result
+          where cstr KChar     nm = ["(= 1 (str.len " ++ nm ++ "))"]
+                cstr KRational nm = ["(< 0 (sbv.rat.denominator " ++ nm ++ "))"]
+                cstr _         _  = []
 
         mkAnd []  = "true"
         mkAnd [c] = c
         mkAnd cs  = "(and " ++ unwords cs ++ ")"
 
-        walk :: Int -> String -> (String -> String) -> Kind -> [String]
-        walk _d _nm _f KBool     {}       = []
-        walk _d _nm _f KBounded  {}       = []
-        walk _d _nm _f KUnbounded{}       = []
-        walk _d _nm _f KReal     {}       = []
-        walk _d _nm _f KUserSort {}       = []
-        walk _d _nm _f KFloat    {}       = []
-        walk _d _nm _f KDouble   {}       = []
-        walk _d _nm _f KFP       {}       = []
-        walk _d  nm  f KChar     {}       = [f nm]
-        walk _d _nm _f KString   {}       = []
-        walk  d  nm _f  (KList k)
-          | charFree k                    = []
+        walk :: Int -> String -> (Kind -> String -> [String]) -> Kind -> [String]
+        walk _d nm f k@KBool     {}         = f k nm
+        walk _d nm f k@KBounded  {}         = f k nm
+        walk _d nm f k@KUnbounded{}         = f k nm
+        walk _d nm f k@KReal     {}         = f k nm
+        walk _d nm f k@KUserSort {}         = f k nm
+        walk _d nm f k@KFloat    {}         = f k nm
+        walk _d nm f k@KDouble   {}         = f k nm
+        walk _d nm f k@KRational {}         = f k nm
+        walk _d nm f k@KFP       {}         = f k nm
+        walk _d nm f k@KChar     {}         = f k nm
+        walk _d nm f k@KString   {}         = f k nm
+        walk  d nm f  (KList k)
+          | charRatFree k                 = []
           | True                          = let fnm   = "seq" ++ show d
-                                                cstrs = walk (d+1) ("(seq.nth " ++ nm ++ " " ++ fnm ++ ")")
-                                                             (\snm -> "(= 1 (str.len " ++ snm ++ "))") k
+                                                cstrs = walk (d+1) ("(seq.nth " ++ nm ++ " " ++ fnm ++ ")") f k
                                             in ["(forall ((" ++ fnm ++ " " ++ smtType KUnbounded ++ ")) " ++ "(=> (and (>= " ++ fnm ++ " 0) (< " ++ fnm ++ " (seq.len " ++ nm ++ "))) " ++ mkAnd cstrs ++ "))"]
-        walk  d  nm  _f (KSet k)
-          | charFree k                    = []
+        walk  d  nm f (KSet k)
+          | charRatFree k                 = []
           | True                          = let fnm    = "set" ++ show d
-                                                cstrs  = walk (d+1) nm (\snm -> "(=> (select " ++ snm ++ " " ++ fnm ++ ") (= 1 (str.len " ++ fnm ++ ")))") k
+                                                cstrs  = walk (d+1) nm (\sk snm -> ["(=> (select " ++ snm ++ " " ++ fnm ++ ") " ++ c ++ ")" | c <- f sk fnm]) k
                                             in ["(forall ((" ++ fnm ++ " " ++ smtType k ++ ")) " ++ mkAnd cstrs ++ ")"]
         walk  d  nm  f (KTuple ks)        = let tt        = "SBVTuple" ++ show (length ks)
                                                 project i = "(proj_" ++ show i ++ "_" ++ tt ++ " " ++ nm ++ ")"
diff --git a/Data/SBV/Tools/GenTest.hs b/Data/SBV/Tools/GenTest.hs
--- a/Data/SBV/Tools/GenTest.hs
+++ b/Data/SBV/Tools/GenTest.hs
@@ -144,6 +144,7 @@
                   KUnbounded        -> let CInteger w = cvVal cv in shexI False True           w
                   KFloat            -> let CFloat   w = cvVal cv in showHFloat w
                   KDouble           -> let CDouble  w = cvVal cv in showHDouble w
+                  KRational         -> error "SBV.renderTest: Unsupported rational number"
                   KFP{}             -> error "SBV.renderTest: Unsupported arbitrary float"
                   KChar             -> error "SBV.renderTest: Unsupported char"
                   KString           -> error "SBV.renderTest: Unsupported string"
@@ -231,6 +232,7 @@
                         k@KBounded{}      -> error $ "SBV.renderTest: Unsupported kind: " ++ show k
                         KFloat            -> "SFloat"
                         KDouble           -> "SDouble"
+                        KRational         -> error "SBV.renderTest: Unsupported rational number"
                         KFP{}             -> error "SBV.renderTest: Unsupported arbitrary float"
                         KChar             -> error "SBV.renderTest: Unsupported char"
                         KString           -> error "SBV.renderTest: Unsupported string"
@@ -252,6 +254,7 @@
                   KUnbounded       -> let CInteger w = cvVal cv in shexI False True           w
                   KFloat           -> let CFloat w   = cvVal cv in showCFloat w
                   KDouble          -> let CDouble w  = cvVal cv in showCDouble w
+                  KRational        -> error "SBV.renderTest: Unsupported rational number"
                   KFP{}            -> error "SBV.renderTest: Unsupported arbitrary float"
                   KChar            -> error "SBV.renderTest: Unsupported char"
                   KString          -> error "SBV.renderTest: Unsupported string"
@@ -336,6 +339,7 @@
         xlt _ (CFloat    r)  = error $ "SBV.renderTest.Forte: Unexpected float value: "            ++ show r
         xlt _ (CDouble   r)  = error $ "SBV.renderTest.Forte: Unexpected double value: "           ++ show r
         xlt _ (CFP       r)  = error $ "SBV.renderTest.Forte: Unexpected arbitrary float value: "  ++ show r
+        xlt _ (CRational r)  = error $ "SBV.renderTest.Forte: Unexpected rational  value: "        ++ show r
         xlt _ (CChar     r)  = error $ "SBV.renderTest.Forte: Unexpected char value: "             ++ show r
         xlt _ (CString   r)  = error $ "SBV.renderTest.Forte: Unexpected string value: "           ++ show r
         xlt _ (CAlgReal  r)  = error $ "SBV.renderTest.Forte: Unexpected real value: "             ++ show r
diff --git a/Data/SBV/Utils/CrackNum.hs b/Data/SBV/Utils/CrackNum.hs
--- a/Data/SBV/Utils/CrackNum.hs
+++ b/Data/SBV/Utils/CrackNum.hs
@@ -52,6 +52,7 @@
                   KTuple     {}  -> Nothing
                   KMaybe     {}  -> Nothing
                   KEither    {}  -> Nothing
+                  KRational  {}  -> Nothing
 
                   -- Actual crackables
                   KFloat{}       -> Just $ let CFloat   f = cvVal cv in float f
diff --git a/Data/SBV/Utils/PrettyNum.hs b/Data/SBV/Utils/PrettyNum.hs
--- a/Data/SBV/Utils/PrettyNum.hs
+++ b/Data/SBV/Utils/PrettyNum.hs
@@ -18,6 +18,7 @@
         PrettyNum(..), readBin, shex, chex, shexI, sbin, sbinI
       , showCFloat, showCDouble, showHFloat, showHDouble, showBFloat, showFloatAtBase
       , showSMTFloat, showSMTDouble, smtRoundingMode, cvToSMTLib, mkSkolemZero
+      , showNegativeNumber
       ) where
 
 import Data.Char  (intToDigit, ord, chr, toUpper)
@@ -395,7 +396,11 @@
    | True                = "((_ to_fp 11 53) " ++ smtRoundingMode rm ++ " " ++ toSMTLibRational (toRational d) ++ ")"
    where as s = "(_ " ++ s ++ " 11 53)"
 
--- | Show a rational in SMTLib format
+-- | Show an SBV rational as an SMTLib value. This is used for faithful rationals.
+showSMTRational :: Rational -> String
+showSMTRational r = "(SBV.Rational " ++ showNegativeNumber (numerator r) ++ " " ++ showNegativeNumber (denominator r) ++ ")"
+
+-- | Show a rational in SMTLib format. This is used for conversions from regular rationals.
 toSMTLibRational :: Rational -> String
 toSMTLibRational r
    | n < 0
@@ -413,6 +418,7 @@
   | isReal          x, CAlgReal  r      <- cvVal x = algRealToSMTLib2 r
   | isFloat         x, CFloat    f      <- cvVal x = showSMTFloat  rm f
   | isDouble        x, CDouble   d      <- cvVal x = showSMTDouble rm d
+  | isRational      x, CRational r      <- cvVal x = showSMTRational r
   | isFP            x, CFP       f      <- cvVal x = fprToSMTLib2 f
   | not (isBounded x), CInteger  w      <- cvVal x = if w >= 0 then show w else "(- " ++ show (abs w) ++ ")"
   | not (hasSign x)  , CInteger  w      <- cvVal x = smtLibHex (intSizeOf x) w
@@ -529,3 +535,9 @@
            where d | v <= 15 = [intToDigit v]
                    | v <  36 = [chr (ord 'a' + v - 10)]
                    | True    = '<' : show v ++ ">"
+
+-- | When we show a negative number in SMTLib, we must properly parenthesize.
+showNegativeNumber :: (Show a, Num a, Ord a) => a -> String
+showNegativeNumber i
+  | i < 0 = "(- " ++ show (-i) ++ ")"
+  | True  = show i
diff --git a/Documentation/SBV/Examples/BitPrecise/BrokenSearch.hs b/Documentation/SBV/Examples/BitPrecise/BrokenSearch.hs
--- a/Documentation/SBV/Examples/BitPrecise/BrokenSearch.hs
+++ b/Documentation/SBV/Examples/BitPrecise/BrokenSearch.hs
@@ -21,7 +21,7 @@
 -- Note how we use the overflow checking variants of the arithmetic operators. We have:
 --
 -- >>> checkArithOverflow midPointBroken
--- Documentation/SBV/Examples/BitPrecise/BrokenSearch.hs:35:32:+!: SInt32 addition overflows: Violated. Model:
+-- Documentation/SBV/Examples/BitPrecise/BrokenSearch.hs:35:28:+!: SInt32 addition overflows: Violated. Model:
 --   low  = 2147483647 :: Int32
 --   high = 2147483647 :: Int32
 --
diff --git a/Documentation/SBV/Examples/Existentials/Diophantine.hs b/Documentation/SBV/Examples/Existentials/Diophantine.hs
--- a/Documentation/SBV/Examples/Existentials/Diophantine.hs
+++ b/Documentation/SBV/Examples/Existentials/Diophantine.hs
@@ -74,15 +74,15 @@
 -- We have:
 --
 -- >>> test
--- NonHomogeneous [[1,0,0],[0,2,0]] [[0,1,1],[1,0,2]]
+-- NonHomogeneous [[1,0,0],[0,2,0]] [[1,0,2],[0,1,1]]
 --
 -- which means that the solutions are of the form:
 --
---    @(1, 0, 0) + k (0, 1, 1) + k' (1, 0, 2) = (1+k', k, k+2k')@
+--    @(1, 0, 0) + k (1, 0, 2) + k' (0, 1, 1) = (1+k, k', 2k+k')@
 --
 -- OR
 --
---    @(0, 2, 0) + k (0, 1, 1) + k' (1, 0, 2) = (k', 2+k, k+2k')@
+--    @(0, 2, 0) + k (1, 0, 2) + k' (0, 1, 1) = (k, 2+k', 2k+k')@
 --
 -- for arbitrary @k@, @k'@. It's easy to see that these are really solutions
 -- to the equation given. It's harder to see that they cover all possibilities,
diff --git a/Documentation/SBV/Examples/Misc/Auxiliary.hs b/Documentation/SBV/Examples/Misc/Auxiliary.hs
--- a/Documentation/SBV/Examples/Misc/Auxiliary.hs
+++ b/Documentation/SBV/Examples/Misc/Auxiliary.hs
@@ -36,14 +36,14 @@
 --
 -- >>> allModels
 -- Solution #1:
---   x = 0 :: Integer
---   y = 0 :: Integer
+--   x =  1 :: Integer
+--   y = -1 :: Integer
 -- Solution #2:
 --   x = 1 :: Integer
 --   y = 1 :: Integer
 -- Solution #3:
---   x =  1 :: Integer
---   y = -1 :: Integer
+--   x = 0 :: Integer
+--   y = 0 :: Integer
 -- Found 3 different solutions.
 --
 -- Note that solutions @2@ and @3@ share the value @x = 1@, since there are
@@ -56,9 +56,9 @@
 --
 -- >>> modelsWithYAux
 -- Solution #1:
---   x = 0 :: Integer
--- Solution #2:
 --   x = 1 :: Integer
+-- Solution #2:
+--   x = 0 :: Integer
 -- Found 2 different solutions.
 --
 -- Note that we now have only two solutions, one for each unique value of @x@ that satisfy our
diff --git a/Documentation/SBV/Examples/Misc/Enumerate.hs b/Documentation/SBV/Examples/Misc/Enumerate.hs
--- a/Documentation/SBV/Examples/Misc/Enumerate.hs
+++ b/Documentation/SBV/Examples/Misc/Enumerate.hs
@@ -40,11 +40,11 @@
 --
 -- >>> elts
 -- Solution #1:
---   s0 = A :: E
+--   s0 = C :: E
 -- Solution #2:
 --   s0 = B :: E
 -- Solution #3:
---   s0 = C :: E
+--   s0 = A :: E
 -- Found 3 different solutions.
 elts :: IO AllSatResult
 elts = allSat $ \(x::SE) -> x .== x
diff --git a/Documentation/SBV/Examples/Uninterpreted/UISortAllSat.hs b/Documentation/SBV/Examples/Uninterpreted/UISortAllSat.hs
--- a/Documentation/SBV/Examples/Uninterpreted/UISortAllSat.hs
+++ b/Documentation/SBV/Examples/Uninterpreted/UISortAllSat.hs
@@ -47,7 +47,7 @@
 --
 -- >>> allSat genLs
 -- Solution #1:
---   l  = L!val!0 :: L
+--   l  = L!val!2 :: L
 --   l0 = L!val!0 :: L
 --   l1 = L!val!1 :: L
 --   l2 = L!val!2 :: L
@@ -67,7 +67,7 @@
 --   classify L!val!1 = 1
 --   classify _       = 0
 -- Solution #3:
---   l  = L!val!2 :: L
+--   l  = L!val!0 :: L
 --   l0 = L!val!0 :: L
 --   l1 = L!val!1 :: L
 --   l2 = L!val!2 :: L
diff --git a/SBVTestSuite/GoldFiles/allSat2.gold b/SBVTestSuite/GoldFiles/allSat2.gold
--- a/SBVTestSuite/GoldFiles/allSat2.gold
+++ b/SBVTestSuite/GoldFiles/allSat2.gold
@@ -1,9 +1,9 @@
 Solution #1:
   x = Q!val!0 :: Q
   y = Q!val!0 :: Q
-  z = Q!val!0 :: Q
+  z = Q!val!1 :: Q
 Solution #2:
   x = Q!val!0 :: Q
   y = Q!val!0 :: Q
-  z = Q!val!1 :: Q
+  z = Q!val!0 :: Q
 Found 2 different solutions.
diff --git a/SBVTestSuite/GoldFiles/allSat3.gold b/SBVTestSuite/GoldFiles/allSat3.gold
--- a/SBVTestSuite/GoldFiles/allSat3.gold
+++ b/SBVTestSuite/GoldFiles/allSat3.gold
@@ -1,5 +1,5 @@
 Solution #1:
-  s0 = 0.0 :: Float
-Solution #2:
   s0 = -0.0 :: Float
+Solution #2:
+  s0 = 0.0 :: Float
 Found 2 different solutions.
diff --git a/SBVTestSuite/GoldFiles/allSat6.gold b/SBVTestSuite/GoldFiles/allSat6.gold
--- a/SBVTestSuite/GoldFiles/allSat6.gold
+++ b/SBVTestSuite/GoldFiles/allSat6.gold
@@ -1,10 +1,10 @@
 Solution #1:
   x = 0 :: Word8
-  y = 1 :: Word8
+  y = 2 :: Word8
 Solution #2:
   x = 1 :: Word8
   y = 2 :: Word8
 Solution #3:
   x = 0 :: Word8
-  y = 2 :: Word8
+  y = 1 :: Word8
 Found 3 different solutions. (Unique up to prefix existentials.)
diff --git a/SBVTestSuite/GoldFiles/allSat7.gold b/SBVTestSuite/GoldFiles/allSat7.gold
new file mode 100644
--- /dev/null
+++ b/SBVTestSuite/GoldFiles/allSat7.gold
@@ -0,0 +1,34482 @@
+** 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) ; has unbounded values, using catch-all.
+[GOOD] ; --- uninterpreted sorts ---
+[GOOD] ; --- tuples ---
+[GOOD] ; --- sums ---
+[GOOD] ; --- literal constants ---
+[GOOD] (define-fun s3 () Int 1)
+[GOOD] (define-fun s5 () Int 15)
+[GOOD] ; --- skolem constants ---
+[GOOD] (declare-fun s0 () Int) ; tracks user variable "x"
+[GOOD] (declare-fun s1 () Int) ; tracks user variable "y"
+[GOOD] (declare-fun s2 () Int) ; tracks user variable "z"
+[GOOD] ; --- constant tables ---
+[GOOD] ; --- skolemized tables ---
+[GOOD] ; --- arrays ---
+[GOOD] ; --- uninterpreted constants ---
+[GOOD] ; --- user given axioms ---
+[GOOD] ; --- formula ---
+[GOOD] (define-fun s4 () Bool (>= s0 s3))
+[GOOD] (define-fun s6 () Bool (<= s0 s5))
+[GOOD] (define-fun s7 () Bool (and s4 s6))
+[GOOD] (define-fun s8 () Bool (>= s1 s3))
+[GOOD] (define-fun s9 () Bool (<= s1 s5))
+[GOOD] (define-fun s10 () Bool (and s8 s9))
+[GOOD] (define-fun s11 () Bool (>= s2 s3))
+[GOOD] (define-fun s12 () Bool (<= s2 s5))
+[GOOD] (define-fun s13 () Bool (and s11 s12))
+[GOOD] (define-fun s14 () Bool (distinct s0 s1 s2))
+[GOOD] (assert s7)
+[GOOD] (assert s10)
+[GOOD] (assert s13)
+[GOOD] (assert s14)
+*** Checking Satisfiability, all solutions..
+Fast allSat, Looking for solution 1
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 1))
+[SEND] (get-value (s1))
+[RECV] ((s1 2))
+[SEND] (get-value (s2))
+[RECV] ((s2 3))
+[GOOD] (push 1)
+[GOOD] (define-fun s15 () Bool (distinct s0 s3))
+[GOOD] (assert s15)
+Fast allSat, Looking for solution 2
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 3))
+[SEND] (get-value (s1))
+[RECV] ((s1 1))
+[SEND] (get-value (s2))
+[RECV] ((s2 2))
+[GOOD] (push 1)
+[GOOD] (define-fun s16 () Int 3)
+[GOOD] (define-fun s17 () Bool (distinct s0 s16))
+[GOOD] (assert s17)
+Fast allSat, Looking for solution 3
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 2))
+[SEND] (get-value (s1))
+[RECV] ((s1 1))
+[SEND] (get-value (s2))
+[RECV] ((s2 3))
+[GOOD] (push 1)
+[GOOD] (define-fun s18 () Int 2)
+[GOOD] (define-fun s19 () Bool (distinct s0 s18))
+[GOOD] (assert s19)
+Fast allSat, Looking for solution 4
+[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] (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 15))
+[GOOD] (push 1)
+[GOOD] (assert s89)
+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 11))
+[GOOD] (push 1)
+[GOOD] (assert s61)
+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 15))
+[GOOD] (push 1)
+[GOOD] (assert s89)
+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 11))
+[GOOD] (push 1)
+[GOOD] (assert s61)
+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 15))
+[GOOD] (push 1)
+[GOOD] (assert s89)
+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 14))
+[GOOD] (push 1)
+[GOOD] (assert s72)
+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 13))
+[GOOD] (push 1)
+[GOOD] (assert s58)
+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 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 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 15))
+[GOOD] (push 1)
+[GOOD] (assert s89)
+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 14))
+[GOOD] (push 1)
+[GOOD] (assert s72)
+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 13))
+[GOOD] (push 1)
+[GOOD] (assert s58)
+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 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 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 10))
+[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 s62)
+[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 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 15))
+[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 15))
+[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 15))
+[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 15))
+[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 15))
+[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 15))
+[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 15))
+[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 15))
+[SEND] (get-value (s2))
+[RECV] ((s2 1))
+[GOOD] (push 1)
+[GOOD] (assert s71)
+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 12))
+[GOOD] (push 1)
+[GOOD] (assert s60)
+Fast allSat, Looking for solution 763
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 11))
+[SEND] (get-value (s1))
+[RECV] ((s1 15))
+[SEND] (get-value (s2))
+[RECV] ((s2 13))
+[GOOD] (push 1)
+[GOOD] (assert s58)
+Fast allSat, Looking for solution 764
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 11))
+[SEND] (get-value (s1))
+[RECV] ((s1 15))
+[SEND] (get-value (s2))
+[RECV] ((s2 14))
+[GOOD] (push 1)
+[GOOD] (assert s72)
+Fast allSat, Looking for solution 765
+[SEND] (check-sat)
+[RECV] unsat
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (push 1)
+[GOOD] (assert 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 13))
+[GOOD] (push 1)
+[GOOD] (assert s58)
+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 12))
+[GOOD] (push 1)
+[GOOD] (assert s60)
+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 10))
+[GOOD] (push 1)
+[GOOD] (assert s62)
+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 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 14))
+[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 14))
+[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 14))
+[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 14))
+[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 14))
+[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 14))
+[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 14))
+[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 14))
+[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 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 10))
+[GOOD] (push 1)
+[GOOD] (assert s62)
+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 12))
+[GOOD] (push 1)
+[GOOD] (assert s60)
+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 15))
+[GOOD] (push 1)
+[GOOD] (assert s89)
+Fast allSat, Looking for solution 838
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 11))
+[SEND] (get-value (s1))
+[RECV] ((s1 7))
+[SEND] (get-value (s2))
+[RECV] ((s2 14))
+[GOOD] (push 1)
+[GOOD] (assert s72)
+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 12))
+[GOOD] (push 1)
+[GOOD] (assert s60)
+Fast allSat, Looking for solution 841
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 11))
+[SEND] (get-value (s1))
+[RECV] ((s1 7))
+[SEND] (get-value (s2))
+[RECV] ((s2 9))
+[GOOD] (push 1)
+[GOOD] (assert s63)
+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 13))
+[GOOD] (push 1)
+[GOOD] (assert s58)
+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 12))
+[GOOD] (push 1)
+[GOOD] (assert s60)
+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 11))
+[GOOD] (push 1)
+[GOOD] (assert s61)
+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 10))
+[GOOD] (push 1)
+[GOOD] (assert s62)
+Fast allSat, Looking for solution 1131
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 9))
+[SEND] (get-value (s1))
+[RECV] ((s1 14))
+[SEND] (get-value (s2))
+[RECV] ((s2 15))
+[GOOD] (push 1)
+[GOOD] (assert s89)
+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 10))
+[GOOD] (push 1)
+[GOOD] (assert s62)
+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 11))
+[GOOD] (push 1)
+[GOOD] (assert s61)
+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 14))
+[GOOD] (push 1)
+[GOOD] (assert s72)
+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 15))
+[GOOD] (push 1)
+[GOOD] (assert s89)
+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 15))
+[GOOD] (push 1)
+[GOOD] (assert s89)
+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 14))
+[GOOD] (push 1)
+[GOOD] (assert s72)
+Fast allSat, Looking for solution 1153
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 9))
+[SEND] (get-value (s1))
+[RECV] ((s1 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 11))
+[GOOD] (push 1)
+[GOOD] (assert s61)
+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 10))
+[GOOD] (push 1)
+[GOOD] (assert s62)
+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 10))
+[GOOD] (push 1)
+[GOOD] (assert s62)
+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 12))
+[GOOD] (push 1)
+[GOOD] (assert s60)
+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 13))
+[GOOD] (push 1)
+[GOOD] (assert s58)
+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 14))
+[GOOD] (push 1)
+[GOOD] (assert s72)
+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 15))
+[GOOD] (push 1)
+[GOOD] (assert s89)
+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 15))
+[GOOD] (push 1)
+[GOOD] (assert s89)
+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 14))
+[GOOD] (push 1)
+[GOOD] (assert s72)
+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 12))
+[GOOD] (push 1)
+[GOOD] (assert s60)
+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 11))
+[GOOD] (push 1)
+[GOOD] (assert s61)
+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 9))
+[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 10))
+[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 11))
+[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 12))
+[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 13))
+[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 14))
+[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 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 s72)
+[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 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 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 s58)
+[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 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 s60)
+[GOOD] (assert s75)
+Fast allSat, Looking for solution 1344
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 8))
+[SEND] (get-value (s1))
+[RECV] ((s1 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 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 s61)
+[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 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 s62)
+[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 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 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 s63)
+[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 6))
+[GOOD] (push 1)
+[GOOD] (assert s66)
+Fast allSat, Looking for solution 1387
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 8))
+[SEND] (get-value (s1))
+[RECV] ((s1 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 3))
+[GOOD] (push 1)
+[GOOD] (assert s69)
+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 2))
+[GOOD] (push 1)
+[GOOD] (assert s70)
+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 1))
+[GOOD] (push 1)
+[GOOD] (assert s71)
+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 6))
+[GOOD] (push 1)
+[GOOD] (assert s66)
+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 15))
+[GOOD] (push 1)
+[GOOD] (assert s89)
+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 1))
+[GOOD] (push 1)
+[GOOD] (assert s71)
+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 5))
+[GOOD] (push 1)
+[GOOD] (assert s67)
+Fast allSat, Looking for solution 1544
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 7))
+[SEND] (get-value (s1))
+[RECV] ((s1 4))
+[SEND] (get-value (s2))
+[RECV] ((s2 12))
+[GOOD] (push 1)
+[GOOD] (assert s60)
+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 13))
+[GOOD] (push 1)
+[GOOD] (assert s58)
+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 14))
+[GOOD] (push 1)
+[GOOD] (assert s72)
+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 13))
+[GOOD] (push 1)
+[GOOD] (assert s58)
+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 14))
+[GOOD] (push 1)
+[GOOD] (assert s72)
+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 15))
+[GOOD] (push 1)
+[GOOD] (assert s89)
+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 6))
+[GOOD] (push 1)
+[GOOD] (assert s66)
+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 5))
+[GOOD] (push 1)
+[GOOD] (assert s67)
+Fast allSat, Looking for solution 1629
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 7))
+[SEND] (get-value (s1))
+[RECV] ((s1 9))
+[SEND] (get-value (s2))
+[RECV] ((s2 4))
+[GOOD] (push 1)
+[GOOD] (assert s68)
+Fast allSat, Looking for solution 1630
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 7))
+[SEND] (get-value (s1))
+[RECV] ((s1 9))
+[SEND] (get-value (s2))
+[RECV] ((s2 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 6))
+[GOOD] (push 1)
+[GOOD] (assert s66)
+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 5))
+[GOOD] (push 1)
+[GOOD] (assert s67)
+Fast allSat, Looking for solution 1635
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 7))
+[SEND] (get-value (s1))
+[RECV] ((s1 1))
+[SEND] (get-value (s2))
+[RECV] ((s2 4))
+[GOOD] (push 1)
+[GOOD] (assert s68)
+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 3))
+[GOOD] (push 1)
+[GOOD] (assert s69)
+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 2))
+[GOOD] (push 1)
+[GOOD] (assert s70)
+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 9))
+[GOOD] (push 1)
+[GOOD] (assert s63)
+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 10))
+[GOOD] (push 1)
+[GOOD] (assert s62)
+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 11))
+[GOOD] (push 1)
+[GOOD] (assert s61)
+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 12))
+[GOOD] (push 1)
+[GOOD] (assert s60)
+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 13))
+[GOOD] (push 1)
+[GOOD] (assert s58)
+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 14))
+[GOOD] (push 1)
+[GOOD] (assert s72)
+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 2))
+[SEND] (get-value (s2))
+[RECV] ((s2 15))
+[GOOD] (push 1)
+[GOOD] (assert s45)
+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 15))
+[GOOD] (push 1)
+[GOOD] (assert s46)
+Fast allSat, Looking for solution 1647
+[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 s47)
+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 15))
+[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 7))
+[SEND] (get-value (s2))
+[RECV] ((s2 15))
+[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 15))
+[GOOD] (push 1)
+[GOOD] (assert s51)
+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 15))
+[GOOD] (push 1)
+[GOOD] (assert s52)
+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 15))
+[GOOD] (push 1)
+[GOOD] (assert s53)
+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 15))
+[GOOD] (push 1)
+[GOOD] (assert s54)
+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 15))
+[GOOD] (push 1)
+[GOOD] (assert s55)
+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 15))
+[GOOD] (push 1)
+[GOOD] (assert s56)
+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 5))
+[GOOD] (push 1)
+[GOOD] (assert s67)
+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 4))
+[GOOD] (push 1)
+[GOOD] (assert s68)
+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 3))
+[GOOD] (push 1)
+[GOOD] (assert s69)
+Fast allSat, Looking for solution 1673
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 6))
+[SEND] (get-value (s1))
+[RECV] ((s1 14))
+[SEND] (get-value (s2))
+[RECV] ((s2 2))
+[GOOD] (push 1)
+[GOOD] (assert s70)
+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 1))
+[GOOD] (push 1)
+[GOOD] (assert s71)
+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 7))
+[GOOD] (push 1)
+[GOOD] (assert s65)
+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 8))
+[GOOD] (push 1)
+[GOOD] (assert s64)
+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 9))
+[GOOD] (push 1)
+[GOOD] (assert s63)
+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 10))
+[GOOD] (push 1)
+[GOOD] (assert s62)
+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 11))
+[GOOD] (push 1)
+[GOOD] (assert s61)
+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 12))
+[GOOD] (push 1)
+[GOOD] (assert s60)
+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 13))
+[GOOD] (push 1)
+[GOOD] (assert s58)
+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 s89)
+[GOOD] (assert s73)
+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 12))
+[GOOD] (push 1)
+[GOOD] (assert s60)
+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 11))
+[GOOD] (push 1)
+[GOOD] (assert s61)
+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 10))
+[GOOD] (push 1)
+[GOOD] (assert s62)
+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 9))
+[GOOD] (push 1)
+[GOOD] (assert s63)
+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 8))
+[GOOD] (push 1)
+[GOOD] (assert s64)
+Fast allSat, Looking for solution 1687
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 6))
+[SEND] (get-value (s1))
+[RECV] ((s1 13))
+[SEND] (get-value (s2))
+[RECV] ((s2 7))
+[GOOD] (push 1)
+[GOOD] (assert s65)
+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 14))
+[GOOD] (push 1)
+[GOOD] (assert s72)
+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 s89)
+[GOOD] (assert s74)
+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 5))
+[GOOD] (push 1)
+[GOOD] (assert s67)
+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 4))
+[GOOD] (push 1)
+[GOOD] (assert s68)
+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 3))
+[GOOD] (push 1)
+[GOOD] (assert s69)
+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 2))
+[GOOD] (push 1)
+[GOOD] (assert s70)
+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 1))
+[GOOD] (push 1)
+[GOOD] (assert s71)
+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 7))
+[GOOD] (push 1)
+[GOOD] (assert s65)
+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 8))
+[GOOD] (push 1)
+[GOOD] (assert s64)
+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 9))
+[GOOD] (push 1)
+[GOOD] (assert s63)
+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 10))
+[GOOD] (push 1)
+[GOOD] (assert s62)
+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 11))
+[GOOD] (push 1)
+[GOOD] (assert s61)
+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 13))
+[GOOD] (push 1)
+[GOOD] (assert s58)
+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 14))
+[GOOD] (push 1)
+[GOOD] (assert s72)
+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 s89)
+[GOOD] (assert s75)
+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 14))
+[GOOD] (push 1)
+[GOOD] (assert s72)
+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 13))
+[GOOD] (push 1)
+[GOOD] (assert s58)
+Fast allSat, Looking for solution 1708
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 6))
+[SEND] (get-value (s1))
+[RECV] ((s1 11))
+[SEND] (get-value (s2))
+[RECV] ((s2 12))
+[GOOD] (push 1)
+[GOOD] (assert s60)
+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 10))
+[GOOD] (push 1)
+[GOOD] (assert s62)
+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 9))
+[GOOD] (push 1)
+[GOOD] (assert s63)
+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 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 11))
+[SEND] (get-value (s2))
+[RECV] ((s2 7))
+[GOOD] (push 1)
+[GOOD] (assert s65)
+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 5))
+[GOOD] (push 1)
+[GOOD] (assert s67)
+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 4))
+[GOOD] (push 1)
+[GOOD] (assert s68)
+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 3))
+[GOOD] (push 1)
+[GOOD] (assert s69)
+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 2))
+[GOOD] (push 1)
+[GOOD] (assert s70)
+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 1))
+[GOOD] (push 1)
+[GOOD] (assert s71)
+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 s89)
+[GOOD] (assert s76)
+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 5))
+[GOOD] (push 1)
+[GOOD] (assert s67)
+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 4))
+[GOOD] (push 1)
+[GOOD] (assert s68)
+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 3))
+[GOOD] (push 1)
+[GOOD] (assert s69)
+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 2))
+[GOOD] (push 1)
+[GOOD] (assert s70)
+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 1))
+[GOOD] (push 1)
+[GOOD] (assert s71)
+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 7))
+[GOOD] (push 1)
+[GOOD] (assert s65)
+Fast allSat, Looking for solution 1724
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 6))
+[SEND] (get-value (s1))
+[RECV] ((s1 10))
+[SEND] (get-value (s2))
+[RECV] ((s2 8))
+[GOOD] (push 1)
+[GOOD] (assert s64)
+Fast allSat, Looking for solution 1725
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 6))
+[SEND] (get-value (s1))
+[RECV] ((s1 10))
+[SEND] (get-value (s2))
+[RECV] ((s2 9))
+[GOOD] (push 1)
+[GOOD] (assert s63)
+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 11))
+[GOOD] (push 1)
+[GOOD] (assert s61)
+Fast allSat, Looking for solution 1727
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 6))
+[SEND] (get-value (s1))
+[RECV] ((s1 10))
+[SEND] (get-value (s2))
+[RECV] ((s2 12))
+[GOOD] (push 1)
+[GOOD] (assert s60)
+Fast allSat, Looking for solution 1728
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 6))
+[SEND] (get-value (s1))
+[RECV] ((s1 10))
+[SEND] (get-value (s2))
+[RECV] ((s2 13))
+[GOOD] (push 1)
+[GOOD] (assert s58)
+Fast allSat, Looking for solution 1729
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 6))
+[SEND] (get-value (s1))
+[RECV] ((s1 10))
+[SEND] (get-value (s2))
+[RECV] ((s2 14))
+[GOOD] (push 1)
+[GOOD] (assert s72)
+Fast allSat, Looking for solution 1730
+[SEND] (check-sat)
+[RECV] unsat
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (push 1)
+[GOOD] (assert s89)
+[GOOD] (assert s77)
+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 14))
+[GOOD] (push 1)
+[GOOD] (assert s72)
+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 13))
+[GOOD] (push 1)
+[GOOD] (assert s58)
+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 12))
+[GOOD] (push 1)
+[GOOD] (assert s60)
+Fast allSat, Looking for solution 1733
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 6))
+[SEND] (get-value (s1))
+[RECV] ((s1 9))
+[SEND] (get-value (s2))
+[RECV] ((s2 11))
+[GOOD] (push 1)
+[GOOD] (assert s61)
+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 10))
+[GOOD] (push 1)
+[GOOD] (assert s62)
+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 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 9))
+[SEND] (get-value (s2))
+[RECV] ((s2 7))
+[GOOD] (push 1)
+[GOOD] (assert s65)
+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 5))
+[GOOD] (push 1)
+[GOOD] (assert s67)
+Fast allSat, Looking for solution 1738
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 6))
+[SEND] (get-value (s1))
+[RECV] ((s1 9))
+[SEND] (get-value (s2))
+[RECV] ((s2 4))
+[GOOD] (push 1)
+[GOOD] (assert s68)
+Fast allSat, Looking for solution 1739
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 6))
+[SEND] (get-value (s1))
+[RECV] ((s1 9))
+[SEND] (get-value (s2))
+[RECV] ((s2 3))
+[GOOD] (push 1)
+[GOOD] (assert s69)
+Fast allSat, Looking for solution 1740
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 6))
+[SEND] (get-value (s1))
+[RECV] ((s1 9))
+[SEND] (get-value (s2))
+[RECV] ((s2 2))
+[GOOD] (push 1)
+[GOOD] (assert s70)
+Fast allSat, Looking for solution 1741
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 6))
+[SEND] (get-value (s1))
+[RECV] ((s1 9))
+[SEND] (get-value (s2))
+[RECV] ((s2 1))
+[GOOD] (push 1)
+[GOOD] (assert s71)
+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 s89)
+[GOOD] (assert s78)
+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 5))
+[GOOD] (push 1)
+[GOOD] (assert s67)
+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 4))
+[GOOD] (push 1)
+[GOOD] (assert s68)
+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 3))
+[GOOD] (push 1)
+[GOOD] (assert s69)
+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 2))
+[GOOD] (push 1)
+[GOOD] (assert s70)
+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 1))
+[GOOD] (push 1)
+[GOOD] (assert s71)
+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 7))
+[GOOD] (push 1)
+[GOOD] (assert s65)
+Fast allSat, Looking for solution 1748
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 6))
+[SEND] (get-value (s1))
+[RECV] ((s1 8))
+[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 8))
+[SEND] (get-value (s2))
+[RECV] ((s2 10))
+[GOOD] (push 1)
+[GOOD] (assert s62)
+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 11))
+[GOOD] (push 1)
+[GOOD] (assert s61)
+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 12))
+[GOOD] (push 1)
+[GOOD] (assert s60)
+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 13))
+[GOOD] (push 1)
+[GOOD] (assert s58)
+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 14))
+[GOOD] (push 1)
+[GOOD] (assert s72)
+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 s89)
+[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 14))
+[GOOD] (push 1)
+[GOOD] (assert s72)
+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 13))
+[GOOD] (push 1)
+[GOOD] (assert s58)
+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 12))
+[GOOD] (push 1)
+[GOOD] (assert s60)
+Fast allSat, Looking for solution 1757
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 6))
+[SEND] (get-value (s1))
+[RECV] ((s1 7))
+[SEND] (get-value (s2))
+[RECV] ((s2 11))
+[GOOD] (push 1)
+[GOOD] (assert s61)
+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 10))
+[GOOD] (push 1)
+[GOOD] (assert s62)
+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 8))
+[GOOD] (push 1)
+[GOOD] (assert s64)
+Fast allSat, Looking for solution 1761
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 6))
+[SEND] (get-value (s1))
+[RECV] ((s1 7))
+[SEND] (get-value (s2))
+[RECV] ((s2 5))
+[GOOD] (push 1)
+[GOOD] (assert s67)
+Fast allSat, Looking for solution 1762
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 6))
+[SEND] (get-value (s1))
+[RECV] ((s1 7))
+[SEND] (get-value (s2))
+[RECV] ((s2 4))
+[GOOD] (push 1)
+[GOOD] (assert s68)
+Fast allSat, Looking for solution 1763
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 6))
+[SEND] (get-value (s1))
+[RECV] ((s1 7))
+[SEND] (get-value (s2))
+[RECV] ((s2 3))
+[GOOD] (push 1)
+[GOOD] (assert s69)
+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 2))
+[GOOD] (push 1)
+[GOOD] (assert s70)
+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 1))
+[GOOD] (push 1)
+[GOOD] (assert s71)
+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 s89)
+[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 4))
+[GOOD] (push 1)
+[GOOD] (assert s68)
+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 3))
+[GOOD] (push 1)
+[GOOD] (assert s69)
+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 2))
+[GOOD] (push 1)
+[GOOD] (assert s70)
+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 1))
+[GOOD] (push 1)
+[GOOD] (assert s71)
+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 7))
+[GOOD] (push 1)
+[GOOD] (assert s65)
+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 8))
+[GOOD] (push 1)
+[GOOD] (assert s64)
+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 10))
+[GOOD] (push 1)
+[GOOD] (assert s62)
+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 11))
+[GOOD] (push 1)
+[GOOD] (assert s61)
+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 12))
+[GOOD] (push 1)
+[GOOD] (assert s60)
+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 13))
+[GOOD] (push 1)
+[GOOD] (assert s58)
+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 14))
+[GOOD] (push 1)
+[GOOD] (assert s72)
+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 s89)
+[GOOD] (assert s82)
+Fast allSat, Looking for solution 1778
+[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 1779
+[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 1780
+[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 1781
+[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 1782
+[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 1783
+[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 1784
+[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 1785
+[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 s65)
+Fast allSat, Looking for solution 1786
+[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 1787
+[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 1788
+[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 1789
+[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 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 s89)
+[GOOD] (assert s83)
+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 2))
+[GOOD] (push 1)
+[GOOD] (assert s70)
+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 1))
+[GOOD] (push 1)
+[GOOD] (assert s71)
+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 4))
+[GOOD] (push 1)
+[GOOD] (assert s68)
+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 5))
+[GOOD] (push 1)
+[GOOD] (assert s67)
+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 7))
+[GOOD] (push 1)
+[GOOD] (assert s65)
+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 8))
+[GOOD] (push 1)
+[GOOD] (assert s64)
+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 10))
+[GOOD] (push 1)
+[GOOD] (assert s62)
+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 11))
+[GOOD] (push 1)
+[GOOD] (assert s61)
+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 12))
+[GOOD] (push 1)
+[GOOD] (assert s60)
+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 13))
+[GOOD] (push 1)
+[GOOD] (assert s58)
+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 14))
+[GOOD] (push 1)
+[GOOD] (assert s72)
+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 s89)
+[GOOD] (assert s84)
+Fast allSat, Looking for solution 1802
+[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 1803
+[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 1804
+[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 1805
+[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 1806
+[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 1807
+[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 1808
+[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 1809
+[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 s65)
+Fast allSat, Looking for solution 1810
+[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 1811
+[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 1812
+[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 1813
+[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 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 2))
+[GOOD] (push 1)
+[GOOD] (assert s70)
+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 3))
+[GOOD] (push 1)
+[GOOD] (assert s69)
+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 4))
+[GOOD] (push 1)
+[GOOD] (assert s68)
+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 5))
+[GOOD] (push 1)
+[GOOD] (assert s67)
+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 8))
+[GOOD] (push 1)
+[GOOD] (assert s64)
+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 9))
+[GOOD] (push 1)
+[GOOD] (assert s63)
+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 10))
+[GOOD] (push 1)
+[GOOD] (assert s62)
+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 11))
+[GOOD] (push 1)
+[GOOD] (assert s61)
+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 12))
+[GOOD] (push 1)
+[GOOD] (assert s60)
+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 13))
+[GOOD] (push 1)
+[GOOD] (assert s58)
+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 14))
+[GOOD] (push 1)
+[GOOD] (assert s72)
+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 15))
+[GOOD] (push 1)
+[GOOD] (assert s89)
+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 15))
+[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 15))
+[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 15))
+[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 15))
+[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 15))
+[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 15))
+[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 15))
+[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 15))
+[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 15))
+[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 15))
+[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 15))
+[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 15))
+[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 14))
+[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 s72)
+[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 13))
+[GOOD] (push 1)
+[GOOD] (assert s58)
+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 12))
+[GOOD] (push 1)
+[GOOD] (assert s60)
+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 11))
+[GOOD] (push 1)
+[GOOD] (assert s61)
+Fast allSat, Looking for solution 1842
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 5))
+[SEND] (get-value (s1))
+[RECV] ((s1 15))
+[SEND] (get-value (s2))
+[RECV] ((s2 10))
+[GOOD] (push 1)
+[GOOD] (assert s62)
+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 9))
+[GOOD] (push 1)
+[GOOD] (assert s63)
+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 7))
+[GOOD] (push 1)
+[GOOD] (assert s65)
+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 6))
+[GOOD] (push 1)
+[GOOD] (assert s66)
+Fast allSat, Looking for solution 1847
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 5))
+[SEND] (get-value (s1))
+[RECV] ((s1 15))
+[SEND] (get-value (s2))
+[RECV] ((s2 4))
+[GOOD] (push 1)
+[GOOD] (assert s68)
+Fast allSat, Looking for solution 1848
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 5))
+[SEND] (get-value (s1))
+[RECV] ((s1 15))
+[SEND] (get-value (s2))
+[RECV] ((s2 3))
+[GOOD] (push 1)
+[GOOD] (assert s69)
+Fast allSat, Looking for solution 1849
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 5))
+[SEND] (get-value (s1))
+[RECV] ((s1 15))
+[SEND] (get-value (s2))
+[RECV] ((s2 2))
+[GOOD] (push 1)
+[GOOD] (assert s70)
+Fast allSat, Looking for solution 1850
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 5))
+[SEND] (get-value (s1))
+[RECV] ((s1 15))
+[SEND] (get-value (s2))
+[RECV] ((s2 1))
+[GOOD] (push 1)
+[GOOD] (assert s71)
+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 s89)
+[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 4))
+[GOOD] (push 1)
+[GOOD] (assert s68)
+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 3))
+[GOOD] (push 1)
+[GOOD] (assert s69)
+Fast allSat, Looking for solution 1853
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 5))
+[SEND] (get-value (s1))
+[RECV] ((s1 14))
+[SEND] (get-value (s2))
+[RECV] ((s2 2))
+[GOOD] (push 1)
+[GOOD] (assert s70)
+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 1))
+[GOOD] (push 1)
+[GOOD] (assert s71)
+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 6))
+[GOOD] (push 1)
+[GOOD] (assert s66)
+Fast allSat, Looking for solution 1856
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 5))
+[SEND] (get-value (s1))
+[RECV] ((s1 14))
+[SEND] (get-value (s2))
+[RECV] ((s2 7))
+[GOOD] (push 1)
+[GOOD] (assert s65)
+Fast allSat, Looking for solution 1857
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 5))
+[SEND] (get-value (s1))
+[RECV] ((s1 14))
+[SEND] (get-value (s2))
+[RECV] ((s2 8))
+[GOOD] (push 1)
+[GOOD] (assert s64)
+Fast allSat, Looking for solution 1858
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 5))
+[SEND] (get-value (s1))
+[RECV] ((s1 14))
+[SEND] (get-value (s2))
+[RECV] ((s2 9))
+[GOOD] (push 1)
+[GOOD] (assert s63)
+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 10))
+[GOOD] (push 1)
+[GOOD] (assert s62)
+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 11))
+[GOOD] (push 1)
+[GOOD] (assert s61)
+Fast allSat, Looking for solution 1861
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 5))
+[SEND] (get-value (s1))
+[RECV] ((s1 14))
+[SEND] (get-value (s2))
+[RECV] ((s2 12))
+[GOOD] (push 1)
+[GOOD] (assert s60)
+Fast allSat, Looking for solution 1862
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 5))
+[SEND] (get-value (s1))
+[RECV] ((s1 14))
+[SEND] (get-value (s2))
+[RECV] ((s2 13))
+[GOOD] (push 1)
+[GOOD] (assert s58)
+Fast allSat, Looking for solution 1863
+[SEND] (check-sat)
+[RECV] unsat
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (push 1)
+[GOOD] (assert s89)
+[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 12))
+[GOOD] (push 1)
+[GOOD] (assert s60)
+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 11))
+[GOOD] (push 1)
+[GOOD] (assert s61)
+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 10))
+[GOOD] (push 1)
+[GOOD] (assert s62)
+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 9))
+[GOOD] (push 1)
+[GOOD] (assert s63)
+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 8))
+[GOOD] (push 1)
+[GOOD] (assert s64)
+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 7))
+[GOOD] (push 1)
+[GOOD] (assert s65)
+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 6))
+[GOOD] (push 1)
+[GOOD] (assert s66)
+Fast allSat, Looking for solution 1870
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 5))
+[SEND] (get-value (s1))
+[RECV] ((s1 13))
+[SEND] (get-value (s2))
+[RECV] ((s2 4))
+[GOOD] (push 1)
+[GOOD] (assert s68)
+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 3))
+[GOOD] (push 1)
+[GOOD] (assert s69)
+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 2))
+[GOOD] (push 1)
+[GOOD] (assert s70)
+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 1))
+[GOOD] (push 1)
+[GOOD] (assert s71)
+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 14))
+[GOOD] (push 1)
+[GOOD] (assert s72)
+Fast allSat, Looking for solution 1875
+[SEND] (check-sat)
+[RECV] unsat
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (push 1)
+[GOOD] (assert s89)
+[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 13))
+[GOOD] (push 1)
+[GOOD] (assert s58)
+Fast allSat, Looking for solution 1876
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 5))
+[SEND] (get-value (s1))
+[RECV] ((s1 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 11))
+[GOOD] (push 1)
+[GOOD] (assert s61)
+Fast allSat, Looking for solution 1878
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 5))
+[SEND] (get-value (s1))
+[RECV] ((s1 12))
+[SEND] (get-value (s2))
+[RECV] ((s2 10))
+[GOOD] (push 1)
+[GOOD] (assert s62)
+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 9))
+[GOOD] (push 1)
+[GOOD] (assert s63)
+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 8))
+[GOOD] (push 1)
+[GOOD] (assert s64)
+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 7))
+[GOOD] (push 1)
+[GOOD] (assert s65)
+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 6))
+[GOOD] (push 1)
+[GOOD] (assert s66)
+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 4))
+[GOOD] (push 1)
+[GOOD] (assert s68)
+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 s89)
+[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 4))
+[GOOD] (push 1)
+[GOOD] (assert s68)
+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 3))
+[GOOD] (push 1)
+[GOOD] (assert s69)
+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 2))
+[GOOD] (push 1)
+[GOOD] (assert s70)
+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 1))
+[GOOD] (push 1)
+[GOOD] (assert s71)
+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 6))
+[GOOD] (push 1)
+[GOOD] (assert s66)
+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 7))
+[GOOD] (push 1)
+[GOOD] (assert s65)
+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 8))
+[GOOD] (push 1)
+[GOOD] (assert s64)
+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 9))
+[GOOD] (push 1)
+[GOOD] (assert s63)
+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 10))
+[GOOD] (push 1)
+[GOOD] (assert s62)
+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 12))
+[GOOD] (push 1)
+[GOOD] (assert s60)
+Fast allSat, Looking for solution 1897
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 5))
+[SEND] (get-value (s1))
+[RECV] ((s1 11))
+[SEND] (get-value (s2))
+[RECV] ((s2 13))
+[GOOD] (push 1)
+[GOOD] (assert s58)
+Fast allSat, Looking for solution 1898
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 5))
+[SEND] (get-value (s1))
+[RECV] ((s1 11))
+[SEND] (get-value (s2))
+[RECV] ((s2 14))
+[GOOD] (push 1)
+[GOOD] (assert s72)
+Fast allSat, Looking for solution 1899
+[SEND] (check-sat)
+[RECV] unsat
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (push 1)
+[GOOD] (assert s89)
+[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 14))
+[GOOD] (push 1)
+[GOOD] (assert s72)
+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 13))
+[GOOD] (push 1)
+[GOOD] (assert s58)
+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 12))
+[GOOD] (push 1)
+[GOOD] (assert s60)
+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 11))
+[GOOD] (push 1)
+[GOOD] (assert s61)
+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 9))
+[GOOD] (push 1)
+[GOOD] (assert s63)
+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 8))
+[GOOD] (push 1)
+[GOOD] (assert s64)
+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 7))
+[GOOD] (push 1)
+[GOOD] (assert s65)
+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 6))
+[GOOD] (push 1)
+[GOOD] (assert s66)
+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 4))
+[GOOD] (push 1)
+[GOOD] (assert s68)
+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 s89)
+[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 4))
+[GOOD] (push 1)
+[GOOD] (assert s68)
+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 3))
+[GOOD] (push 1)
+[GOOD] (assert s69)
+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 2))
+[GOOD] (push 1)
+[GOOD] (assert s70)
+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 1))
+[GOOD] (push 1)
+[GOOD] (assert s71)
+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 6))
+[GOOD] (push 1)
+[GOOD] (assert s66)
+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 7))
+[GOOD] (push 1)
+[GOOD] (assert s65)
+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 8))
+[GOOD] (push 1)
+[GOOD] (assert s64)
+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 10))
+[GOOD] (push 1)
+[GOOD] (assert s62)
+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 11))
+[GOOD] (push 1)
+[GOOD] (assert s61)
+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 12))
+[GOOD] (push 1)
+[GOOD] (assert s60)
+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 13))
+[GOOD] (push 1)
+[GOOD] (assert s58)
+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 14))
+[GOOD] (push 1)
+[GOOD] (assert s72)
+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 s89)
+[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 14))
+[GOOD] (push 1)
+[GOOD] (assert s72)
+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 13))
+[GOOD] (push 1)
+[GOOD] (assert s58)
+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 12))
+[GOOD] (push 1)
+[GOOD] (assert s60)
+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 11))
+[GOOD] (push 1)
+[GOOD] (assert s61)
+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 10))
+[GOOD] (push 1)
+[GOOD] (assert s62)
+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 9))
+[GOOD] (push 1)
+[GOOD] (assert s63)
+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 7))
+[GOOD] (push 1)
+[GOOD] (assert s65)
+Fast allSat, Looking for solution 1930
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 5))
+[SEND] (get-value (s1))
+[RECV] ((s1 8))
+[SEND] (get-value (s2))
+[RECV] ((s2 6))
+[GOOD] (push 1)
+[GOOD] (assert s66)
+Fast allSat, Looking for solution 1931
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 5))
+[SEND] (get-value (s1))
+[RECV] ((s1 8))
+[SEND] (get-value (s2))
+[RECV] ((s2 4))
+[GOOD] (push 1)
+[GOOD] (assert s68)
+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 s89)
+[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 4))
+[GOOD] (push 1)
+[GOOD] (assert s68)
+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 3))
+[GOOD] (push 1)
+[GOOD] (assert s69)
+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 2))
+[GOOD] (push 1)
+[GOOD] (assert s70)
+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 1))
+[GOOD] (push 1)
+[GOOD] (assert s71)
+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 6))
+[GOOD] (push 1)
+[GOOD] (assert s66)
+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 8))
+[GOOD] (push 1)
+[GOOD] (assert s64)
+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 9))
+[GOOD] (push 1)
+[GOOD] (assert s63)
+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 10))
+[GOOD] (push 1)
+[GOOD] (assert s62)
+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 11))
+[GOOD] (push 1)
+[GOOD] (assert s61)
+Fast allSat, Looking for solution 1944
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 5))
+[SEND] (get-value (s1))
+[RECV] ((s1 7))
+[SEND] (get-value (s2))
+[RECV] ((s2 12))
+[GOOD] (push 1)
+[GOOD] (assert s60)
+Fast allSat, Looking for solution 1945
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 5))
+[SEND] (get-value (s1))
+[RECV] ((s1 7))
+[SEND] (get-value (s2))
+[RECV] ((s2 13))
+[GOOD] (push 1)
+[GOOD] (assert s58)
+Fast allSat, Looking for solution 1946
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 5))
+[SEND] (get-value (s1))
+[RECV] ((s1 7))
+[SEND] (get-value (s2))
+[RECV] ((s2 14))
+[GOOD] (push 1)
+[GOOD] (assert s72)
+Fast allSat, Looking for solution 1947
+[SEND] (check-sat)
+[RECV] unsat
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (push 1)
+[GOOD] (assert s89)
+[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 14))
+[GOOD] (push 1)
+[GOOD] (assert s72)
+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 13))
+[GOOD] (push 1)
+[GOOD] (assert s58)
+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 12))
+[GOOD] (push 1)
+[GOOD] (assert s60)
+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 11))
+[GOOD] (push 1)
+[GOOD] (assert s61)
+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 10))
+[GOOD] (push 1)
+[GOOD] (assert s62)
+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 9))
+[GOOD] (push 1)
+[GOOD] (assert s63)
+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 8))
+[GOOD] (push 1)
+[GOOD] (assert s64)
+Fast allSat, Looking for solution 1954
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 5))
+[SEND] (get-value (s1))
+[RECV] ((s1 6))
+[SEND] (get-value (s2))
+[RECV] ((s2 7))
+[GOOD] (push 1)
+[GOOD] (assert s65)
+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 4))
+[GOOD] (push 1)
+[GOOD] (assert s68)
+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 s89)
+[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 3))
+[GOOD] (push 1)
+[GOOD] (assert s69)
+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 1))
+[GOOD] (push 1)
+[GOOD] (assert s71)
+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 6))
+[GOOD] (push 1)
+[GOOD] (assert s66)
+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 7))
+[GOOD] (push 1)
+[GOOD] (assert s65)
+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 8))
+[GOOD] (push 1)
+[GOOD] (assert s64)
+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 9))
+[GOOD] (push 1)
+[GOOD] (assert s63)
+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 10))
+[GOOD] (push 1)
+[GOOD] (assert s62)
+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 11))
+[GOOD] (push 1)
+[GOOD] (assert s61)
+Fast allSat, Looking for solution 1968
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 5))
+[SEND] (get-value (s1))
+[RECV] ((s1 4))
+[SEND] (get-value (s2))
+[RECV] ((s2 12))
+[GOOD] (push 1)
+[GOOD] (assert s60)
+Fast allSat, Looking for solution 1969
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 5))
+[SEND] (get-value (s1))
+[RECV] ((s1 4))
+[SEND] (get-value (s2))
+[RECV] ((s2 13))
+[GOOD] (push 1)
+[GOOD] (assert s58)
+Fast allSat, Looking for solution 1970
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 5))
+[SEND] (get-value (s1))
+[RECV] ((s1 4))
+[SEND] (get-value (s2))
+[RECV] ((s2 14))
+[GOOD] (push 1)
+[GOOD] (assert s72)
+Fast allSat, Looking for solution 1971
+[SEND] (check-sat)
+[RECV] unsat
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (push 1)
+[GOOD] (assert s89)
+[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 14))
+[GOOD] (push 1)
+[GOOD] (assert s72)
+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 13))
+[GOOD] (push 1)
+[GOOD] (assert s58)
+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 12))
+[GOOD] (push 1)
+[GOOD] (assert s60)
+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 11))
+[GOOD] (push 1)
+[GOOD] (assert s61)
+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 10))
+[GOOD] (push 1)
+[GOOD] (assert s62)
+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 9))
+[GOOD] (push 1)
+[GOOD] (assert s63)
+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 8))
+[GOOD] (push 1)
+[GOOD] (assert s64)
+Fast allSat, Looking for solution 1978
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 5))
+[SEND] (get-value (s1))
+[RECV] ((s1 3))
+[SEND] (get-value (s2))
+[RECV] ((s2 7))
+[GOOD] (push 1)
+[GOOD] (assert s65)
+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 6))
+[GOOD] (push 1)
+[GOOD] (assert s66)
+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 4))
+[GOOD] (push 1)
+[GOOD] (assert s68)
+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 s89)
+[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 4))
+[GOOD] (push 1)
+[GOOD] (assert s68)
+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 6))
+[GOOD] (push 1)
+[GOOD] (assert s66)
+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 7))
+[GOOD] (push 1)
+[GOOD] (assert s65)
+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 8))
+[GOOD] (push 1)
+[GOOD] (assert s64)
+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 9))
+[GOOD] (push 1)
+[GOOD] (assert s63)
+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 10))
+[GOOD] (push 1)
+[GOOD] (assert s62)
+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 11))
+[GOOD] (push 1)
+[GOOD] (assert s61)
+Fast allSat, Looking for solution 1992
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 5))
+[SEND] (get-value (s1))
+[RECV] ((s1 2))
+[SEND] (get-value (s2))
+[RECV] ((s2 12))
+[GOOD] (push 1)
+[GOOD] (assert s60)
+Fast allSat, Looking for solution 1993
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 5))
+[SEND] (get-value (s1))
+[RECV] ((s1 2))
+[SEND] (get-value (s2))
+[RECV] ((s2 13))
+[GOOD] (push 1)
+[GOOD] (assert s58)
+Fast allSat, Looking for solution 1994
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 5))
+[SEND] (get-value (s1))
+[RECV] ((s1 2))
+[SEND] (get-value (s2))
+[RECV] ((s2 14))
+[GOOD] (push 1)
+[GOOD] (assert s72)
+Fast allSat, Looking for solution 1995
+[SEND] (check-sat)
+[RECV] unsat
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (push 1)
+[GOOD] (assert 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 14))
+[GOOD] (push 1)
+[GOOD] (assert s72)
+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 13))
+[GOOD] (push 1)
+[GOOD] (assert s58)
+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 12))
+[GOOD] (push 1)
+[GOOD] (assert s60)
+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 11))
+[GOOD] (push 1)
+[GOOD] (assert s61)
+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 10))
+[GOOD] (push 1)
+[GOOD] (assert s62)
+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 9))
+[GOOD] (push 1)
+[GOOD] (assert s63)
+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 8))
+[GOOD] (push 1)
+[GOOD] (assert s64)
+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 7))
+[GOOD] (push 1)
+[GOOD] (assert s65)
+Fast allSat, Looking for solution 2003
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 5))
+[SEND] (get-value (s1))
+[RECV] ((s1 1))
+[SEND] (get-value (s2))
+[RECV] ((s2 15))
+[GOOD] (push 1)
+[GOOD] (assert s89)
+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 6))
+[GOOD] (push 1)
+[GOOD] (assert s66)
+Fast allSat, Looking for solution 2588
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 1))
+[SEND] (get-value (s1))
+[RECV] ((s1 13))
+[SEND] (get-value (s2))
+[RECV] ((s2 7))
+[GOOD] (push 1)
+[GOOD] (assert s65)
+Fast allSat, Looking for solution 2589
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 1))
+[SEND] (get-value (s1))
+[RECV] ((s1 13))
+[SEND] (get-value (s2))
+[RECV] ((s2 8))
+[GOOD] (push 1)
+[GOOD] (assert s64)
+Fast allSat, Looking for solution 2590
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 1))
+[SEND] (get-value (s1))
+[RECV] ((s1 13))
+[SEND] (get-value (s2))
+[RECV] ((s2 9))
+[GOOD] (push 1)
+[GOOD] (assert s63)
+Fast allSat, Looking for solution 2591
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 1))
+[SEND] (get-value (s1))
+[RECV] ((s1 13))
+[SEND] (get-value (s2))
+[RECV] ((s2 10))
+[GOOD] (push 1)
+[GOOD] (assert s62)
+Fast allSat, Looking for solution 2592
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 1))
+[SEND] (get-value (s1))
+[RECV] ((s1 13))
+[SEND] (get-value (s2))
+[RECV] ((s2 11))
+[GOOD] (push 1)
+[GOOD] (assert s61)
+Fast allSat, Looking for solution 2593
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 1))
+[SEND] (get-value (s1))
+[RECV] ((s1 13))
+[SEND] (get-value (s2))
+[RECV] ((s2 12))
+[GOOD] (push 1)
+[GOOD] (assert s60)
+Fast allSat, Looking for solution 2594
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 1))
+[SEND] (get-value (s1))
+[RECV] ((s1 13))
+[SEND] (get-value (s2))
+[RECV] ((s2 5))
+[GOOD] (push 1)
+[GOOD] (assert s67)
+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 13))
+[GOOD] (push 1)
+[GOOD] (assert s58)
+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 14))
+[GOOD] (push 1)
+[GOOD] (assert s72)
+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 11))
+[GOOD] (push 1)
+[GOOD] (assert s61)
+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 9))
+[GOOD] (push 1)
+[GOOD] (assert s63)
+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 8))
+[GOOD] (push 1)
+[GOOD] (assert s64)
+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 7))
+[GOOD] (push 1)
+[GOOD] (assert s65)
+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 6))
+[GOOD] (push 1)
+[GOOD] (assert s66)
+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 5))
+[GOOD] (push 1)
+[GOOD] (assert s67)
+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 4))
+[GOOD] (push 1)
+[GOOD] (assert s68)
+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 3))
+[GOOD] (push 1)
+[GOOD] (assert s69)
+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 2))
+[GOOD] (push 1)
+[GOOD] (assert s70)
+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 10))
+[GOOD] (push 1)
+[GOOD] (assert s62)
+Fast allSat, Looking for solution 2612
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 1))
+[SEND] (get-value (s1))
+[RECV] ((s1 11))
+[SEND] (get-value (s2))
+[RECV] ((s2 9))
+[GOOD] (push 1)
+[GOOD] (assert s63)
+Fast allSat, Looking for solution 2613
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 1))
+[SEND] (get-value (s1))
+[RECV] ((s1 11))
+[SEND] (get-value (s2))
+[RECV] ((s2 8))
+[GOOD] (push 1)
+[GOOD] (assert s64)
+Fast allSat, Looking for solution 2614
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 1))
+[SEND] (get-value (s1))
+[RECV] ((s1 11))
+[SEND] (get-value (s2))
+[RECV] ((s2 7))
+[GOOD] (push 1)
+[GOOD] (assert s65)
+Fast allSat, Looking for solution 2615
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 1))
+[SEND] (get-value (s1))
+[RECV] ((s1 11))
+[SEND] (get-value (s2))
+[RECV] ((s2 6))
+[GOOD] (push 1)
+[GOOD] (assert s66)
+Fast allSat, Looking for solution 2616
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 1))
+[SEND] (get-value (s1))
+[RECV] ((s1 11))
+[SEND] (get-value (s2))
+[RECV] ((s2 5))
+[GOOD] (push 1)
+[GOOD] (assert s67)
+Fast allSat, Looking for solution 2617
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 1))
+[SEND] (get-value (s1))
+[RECV] ((s1 11))
+[SEND] (get-value (s2))
+[RECV] ((s2 4))
+[GOOD] (push 1)
+[GOOD] (assert s68)
+Fast allSat, Looking for solution 2618
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 1))
+[SEND] (get-value (s1))
+[RECV] ((s1 11))
+[SEND] (get-value (s2))
+[RECV] ((s2 3))
+[GOOD] (push 1)
+[GOOD] (assert s69)
+Fast allSat, Looking for solution 2619
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 1))
+[SEND] (get-value (s1))
+[RECV] ((s1 11))
+[SEND] (get-value (s2))
+[RECV] ((s2 2))
+[GOOD] (push 1)
+[GOOD] (assert s70)
+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 12))
+[GOOD] (push 1)
+[GOOD] (assert s60)
+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 13))
+[GOOD] (push 1)
+[GOOD] (assert s58)
+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 14))
+[GOOD] (push 1)
+[GOOD] (assert s72)
+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 8))
+[GOOD] (push 1)
+[GOOD] (assert s64)
+Fast allSat, Looking for solution 2636
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 1))
+[SEND] (get-value (s1))
+[RECV] ((s1 9))
+[SEND] (get-value (s2))
+[RECV] ((s2 7))
+[GOOD] (push 1)
+[GOOD] (assert s65)
+Fast allSat, Looking for solution 2637
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 1))
+[SEND] (get-value (s1))
+[RECV] ((s1 9))
+[SEND] (get-value (s2))
+[RECV] ((s2 6))
+[GOOD] (push 1)
+[GOOD] (assert s66)
+Fast allSat, Looking for solution 2638
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 1))
+[SEND] (get-value (s1))
+[RECV] ((s1 9))
+[SEND] (get-value (s2))
+[RECV] ((s2 5))
+[GOOD] (push 1)
+[GOOD] (assert s67)
+Fast allSat, Looking for solution 2639
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 1))
+[SEND] (get-value (s1))
+[RECV] ((s1 9))
+[SEND] (get-value (s2))
+[RECV] ((s2 4))
+[GOOD] (push 1)
+[GOOD] (assert s68)
+Fast allSat, Looking for solution 2640
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 1))
+[SEND] (get-value (s1))
+[RECV] ((s1 9))
+[SEND] (get-value (s2))
+[RECV] ((s2 3))
+[GOOD] (push 1)
+[GOOD] (assert s69)
+Fast allSat, Looking for solution 2641
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 1))
+[SEND] (get-value (s1))
+[RECV] ((s1 9))
+[SEND] (get-value (s2))
+[RECV] ((s2 2))
+[GOOD] (push 1)
+[GOOD] (assert s70)
+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 10))
+[GOOD] (push 1)
+[GOOD] (assert s62)
+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 11))
+[GOOD] (push 1)
+[GOOD] (assert s61)
+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 12))
+[GOOD] (push 1)
+[GOOD] (assert s60)
+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 13))
+[GOOD] (push 1)
+[GOOD] (assert s58)
+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 14))
+[GOOD] (push 1)
+[GOOD] (assert s72)
+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 6))
+[GOOD] (push 1)
+[GOOD] (assert s66)
+Fast allSat, Looking for solution 2660
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 1))
+[SEND] (get-value (s1))
+[RECV] ((s1 7))
+[SEND] (get-value (s2))
+[RECV] ((s2 5))
+[GOOD] (push 1)
+[GOOD] (assert s67)
+Fast allSat, Looking for solution 2661
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 1))
+[SEND] (get-value (s1))
+[RECV] ((s1 7))
+[SEND] (get-value (s2))
+[RECV] ((s2 4))
+[GOOD] (push 1)
+[GOOD] (assert s68)
+Fast allSat, Looking for solution 2662
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 1))
+[SEND] (get-value (s1))
+[RECV] ((s1 7))
+[SEND] (get-value (s2))
+[RECV] ((s2 3))
+[GOOD] (push 1)
+[GOOD] (assert s69)
+Fast allSat, Looking for solution 2663
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 1))
+[SEND] (get-value (s1))
+[RECV] ((s1 7))
+[SEND] (get-value (s2))
+[RECV] ((s2 2))
+[GOOD] (push 1)
+[GOOD] (assert s70)
+Fast allSat, Looking for solution 2664
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 1))
+[SEND] (get-value (s1))
+[RECV] ((s1 7))
+[SEND] (get-value (s2))
+[RECV] ((s2 8))
+[GOOD] (push 1)
+[GOOD] (assert s64)
+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 9))
+[GOOD] (push 1)
+[GOOD] (assert s63)
+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 10))
+[GOOD] (push 1)
+[GOOD] (assert s62)
+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 11))
+[GOOD] (push 1)
+[GOOD] (assert s61)
+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 12))
+[GOOD] (push 1)
+[GOOD] (assert s60)
+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 13))
+[GOOD] (push 1)
+[GOOD] (assert s58)
+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 14))
+[GOOD] (push 1)
+[GOOD] (assert s72)
+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 4))
+[GOOD] (push 1)
+[GOOD] (assert s68)
+Fast allSat, Looking for solution 2684
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 1))
+[SEND] (get-value (s1))
+[RECV] ((s1 5))
+[SEND] (get-value (s2))
+[RECV] ((s2 3))
+[GOOD] (push 1)
+[GOOD] (assert s69)
+Fast allSat, Looking for solution 2685
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 1))
+[SEND] (get-value (s1))
+[RECV] ((s1 5))
+[SEND] (get-value (s2))
+[RECV] ((s2 2))
+[GOOD] (push 1)
+[GOOD] (assert s70)
+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 6))
+[GOOD] (push 1)
+[GOOD] (assert s66)
+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 7))
+[GOOD] (push 1)
+[GOOD] (assert s65)
+Fast allSat, Looking for solution 2688
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 1))
+[SEND] (get-value (s1))
+[RECV] ((s1 5))
+[SEND] (get-value (s2))
+[RECV] ((s2 8))
+[GOOD] (push 1)
+[GOOD] (assert s64)
+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 9))
+[GOOD] (push 1)
+[GOOD] (assert s63)
+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 10))
+[GOOD] (push 1)
+[GOOD] (assert s62)
+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 11))
+[GOOD] (push 1)
+[GOOD] (assert s61)
+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 12))
+[GOOD] (push 1)
+[GOOD] (assert s60)
+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 13))
+[GOOD] (push 1)
+[GOOD] (assert s58)
+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 14))
+[GOOD] (push 1)
+[GOOD] (assert s72)
+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)
+Fast allSat, Looking for solution 2719
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 1))
+[SEND] (get-value (s1))
+[RECV] ((s1 2))
+[SEND] (get-value (s2))
+[RECV] ((s2 4))
+[GOOD] (push 1)
+[GOOD] (assert s68)
+Fast allSat, Looking for solution 2720
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 1))
+[SEND] (get-value (s1))
+[RECV] ((s1 2))
+[SEND] (get-value (s2))
+[RECV] ((s2 5))
+[GOOD] (push 1)
+[GOOD] (assert s67)
+Fast allSat, Looking for solution 2721
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 1))
+[SEND] (get-value (s1))
+[RECV] ((s1 2))
+[SEND] (get-value (s2))
+[RECV] ((s2 6))
+[GOOD] (push 1)
+[GOOD] (assert s66)
+Fast allSat, Looking for solution 2722
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 1))
+[SEND] (get-value (s1))
+[RECV] ((s1 2))
+[SEND] (get-value (s2))
+[RECV] ((s2 7))
+[GOOD] (push 1)
+[GOOD] (assert s65)
+Fast allSat, Looking for solution 2723
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 1))
+[SEND] (get-value (s1))
+[RECV] ((s1 2))
+[SEND] (get-value (s2))
+[RECV] ((s2 8))
+[GOOD] (push 1)
+[GOOD] (assert s64)
+Fast allSat, Looking for solution 2724
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 1))
+[SEND] (get-value (s1))
+[RECV] ((s1 2))
+[SEND] (get-value (s2))
+[RECV] ((s2 9))
+[GOOD] (push 1)
+[GOOD] (assert s63)
+Fast allSat, Looking for solution 2725
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 1))
+[SEND] (get-value (s1))
+[RECV] ((s1 2))
+[SEND] (get-value (s2))
+[RECV] ((s2 10))
+[GOOD] (push 1)
+[GOOD] (assert s62)
+Fast allSat, Looking for solution 2726
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 1))
+[SEND] (get-value (s1))
+[RECV] ((s1 2))
+[SEND] (get-value (s2))
+[RECV] ((s2 11))
+[GOOD] (push 1)
+[GOOD] (assert s61)
+Fast allSat, Looking for solution 2727
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 1))
+[SEND] (get-value (s1))
+[RECV] ((s1 2))
+[SEND] (get-value (s2))
+[RECV] ((s2 12))
+[GOOD] (push 1)
+[GOOD] (assert s60)
+Fast allSat, Looking for solution 2728
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 1))
+[SEND] (get-value (s1))
+[RECV] ((s1 2))
+[SEND] (get-value (s2))
+[RECV] ((s2 13))
+[GOOD] (push 1)
+[GOOD] (assert s58)
+Fast allSat, Looking for solution 2729
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 1))
+[SEND] (get-value (s1))
+[RECV] ((s1 2))
+[SEND] (get-value (s2))
+[RECV] ((s2 14))
+[GOOD] (push 1)
+[GOOD] (assert s72)
+Fast allSat, Looking for solution 2730
+[SEND] (check-sat)
+[RECV] sat
+[SEND] (get-value (s0))
+[RECV] ((s0 1))
+[SEND] (get-value (s1))
+[RECV] ((s1 2))
+[SEND] (get-value (s2))
+[RECV] ((s2 15))
+[GOOD] (push 1)
+[GOOD] (assert s89)
+Fast allSat, Looking for solution 2731
+[SEND] (check-sat)
+[RECV] unsat
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+*** Solver   : Z3
+*** Exit code: ExitSuccess
diff --git a/SBVTestSuite/GoldFiles/optFloat1c.gold b/SBVTestSuite/GoldFiles/optFloat1c.gold
--- a/SBVTestSuite/GoldFiles/optFloat1c.gold
+++ b/SBVTestSuite/GoldFiles/optFloat1c.gold
@@ -19,7 +19,7 @@
    Binary layout: 1111 1111 0111 1111 1111 1111 1111 1111
       Hex layout: FF7F FFFF
             Type: Unsigned 32-bit word
-    Binary Value: -0b11111111011111111111111111111111
-     Octal Value: -0o37737777777
+    Binary Value: 0b11111111011111111111111111111111
+     Octal Value: 0o37737777777
    Decimal Value: 4286578687
-       Hex Value: -0xff7fffff
+       Hex Value: 0xff7fffff
diff --git a/SBVTestSuite/GoldFiles/optFloat1d.gold b/SBVTestSuite/GoldFiles/optFloat1d.gold
--- a/SBVTestSuite/GoldFiles/optFloat1d.gold
+++ b/SBVTestSuite/GoldFiles/optFloat1d.gold
@@ -16,7 +16,7 @@
    Binary layout: 1111 1111 1000 0000 0000 0000 0000 0000
       Hex layout: FF80 0000
             Type: Unsigned 32-bit word
-    Binary Value: -0b11111111100000000000000000000000
-     Octal Value: -0o37740000000
+    Binary Value: 0b11111111100000000000000000000000
+     Octal Value: 0o37740000000
    Decimal Value: 4286578688
-       Hex Value: -0xff800000
+       Hex Value: 0xff800000
diff --git a/SBVTestSuite/GoldFiles/optFloat2c.gold b/SBVTestSuite/GoldFiles/optFloat2c.gold
--- a/SBVTestSuite/GoldFiles/optFloat2c.gold
+++ b/SBVTestSuite/GoldFiles/optFloat2c.gold
@@ -19,7 +19,7 @@
    Binary layout: 1111 1111 1110 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111
       Hex layout: FFEF FFFF FFFF FFFF
             Type: Unsigned 64-bit word
-    Binary Value: -0b1111111111101111111111111111111111111111111111111111111111111111
-     Octal Value: -0o1777577777777777777777
+    Binary Value: 0b1111111111101111111111111111111111111111111111111111111111111111
+     Octal Value: 0o1777577777777777777777
    Decimal Value: 18442240474082181119
-       Hex Value: -0xffefffffffffffff
+       Hex Value: 0xffefffffffffffff
diff --git a/SBVTestSuite/GoldFiles/optFloat2d.gold b/SBVTestSuite/GoldFiles/optFloat2d.gold
--- a/SBVTestSuite/GoldFiles/optFloat2d.gold
+++ b/SBVTestSuite/GoldFiles/optFloat2d.gold
@@ -16,7 +16,7 @@
    Binary layout: 1111 1111 1111 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000
       Hex layout: FFF0 0000 0000 0000
             Type: Unsigned 64-bit word
-    Binary Value: -0b1111111111110000000000000000000000000000000000000000000000000000
-     Octal Value: -0o1777600000000000000000
+    Binary Value: 0b1111111111110000000000000000000000000000000000000000000000000000
+     Octal Value: 0o1777600000000000000000
    Decimal Value: 18442240474082181120
-       Hex Value: -0xfff0000000000000
+       Hex Value: 0xfff0000000000000
diff --git a/SBVTestSuite/GoldFiles/optFloat3.gold b/SBVTestSuite/GoldFiles/optFloat3.gold
--- a/SBVTestSuite/GoldFiles/optFloat3.gold
+++ b/SBVTestSuite/GoldFiles/optFloat3.gold
@@ -47,7 +47,7 @@
    Binary layout: 1111 1111 0111 1111 1111 1111 1111 1111
       Hex layout: FF7F FFFF
             Type: Unsigned 32-bit word
-    Binary Value: -0b11111111011111111111111111111111
-     Octal Value: -0o37737777777
+    Binary Value: 0b11111111011111111111111111111111
+     Octal Value: 0o37737777777
    Decimal Value: 4286578687
-       Hex Value: -0xff7fffff
+       Hex Value: 0xff7fffff
diff --git a/SBVTestSuite/GoldFiles/optFloat4.gold b/SBVTestSuite/GoldFiles/optFloat4.gold
--- a/SBVTestSuite/GoldFiles/optFloat4.gold
+++ b/SBVTestSuite/GoldFiles/optFloat4.gold
@@ -47,7 +47,7 @@
    Binary layout: 1000 0000 0000 0000 0000 0000 0000 0010
       Hex layout: 8000 0002
             Type: Unsigned 32-bit word
-    Binary Value: -0b10000000000000000000000000000010
-     Octal Value: -0o20000000002
+    Binary Value: 0b10000000000000000000000000000010
+     Octal Value: 0o20000000002
    Decimal Value: 2147483650
-       Hex Value: -0x80000002
+       Hex Value: 0x80000002
diff --git a/SBVTestSuite/GoldFiles/set_uninterp1.gold b/SBVTestSuite/GoldFiles/set_uninterp1.gold
--- a/SBVTestSuite/GoldFiles/set_uninterp1.gold
+++ b/SBVTestSuite/GoldFiles/set_uninterp1.gold
@@ -26,100 +26,116 @@
 [GOOD] ; --- user given axioms ---
 [GOOD] ; --- formula ---
 *** Checking Satisfiability, all solutions..
-Looking for solution 1
+Fast allSat, Looking for solution 1
 [SEND] (check-sat)
 [RECV] sat
 [SEND] (get-value (s0))
 [RECV] ((s0 ((as const (Array E Bool)) false)))
+[GOOD] (push 1)
 [GOOD] (define-fun s1 () (Array E Bool) ((as const (Array E Bool)) false))
 [GOOD] (define-fun s2 () Bool (= s0 s1))
 [GOOD] (define-fun s3 () Bool (not s2))
 [GOOD] (assert s3)
-Looking for solution 2
+Fast allSat, Looking for solution 2
 [SEND] (check-sat)
 [RECV] sat
 [SEND] (get-value (s0))
 [RECV] ((s0 (lambda ((x!1 E)) (= x!1 A))))
+[GOOD] (push 1)
 [GOOD] (define-fun s4 () (Array E Bool) (store ((as const (Array E Bool)) false) A true))
 [GOOD] (define-fun s5 () Bool (= s0 s4))
 [GOOD] (define-fun s6 () Bool (not s5))
 [GOOD] (assert s6)
-Looking for solution 3
+Fast allSat, Looking for solution 3
 [SEND] (check-sat)
 [RECV] sat
 [SEND] (get-value (s0))
-[RECV] ((s0 (store (store ((as const (Array E Bool)) false) B true) A true)))
-[GOOD] (define-fun s7 () (Array E Bool) (store (store ((as const (Array E Bool)) false) B true) A true))
+[RECV] ((s0 (lambda ((x!1 E)) (= x!1 B))))
+[GOOD] (push 1)
+[GOOD] (define-fun s7 () (Array E Bool) (store ((as const (Array E Bool)) false) B true))
 [GOOD] (define-fun s8 () Bool (= s0 s7))
 [GOOD] (define-fun s9 () Bool (not s8))
 [GOOD] (assert s9)
-Looking for solution 4
+Fast allSat, Looking for solution 4
 [SEND] (check-sat)
 [RECV] sat
 [SEND] (get-value (s0))
-[RECV] ((s0 (store (store ((as const (Array E Bool)) false) C true) A true)))
-[GOOD] (define-fun s10 () (Array E Bool) (store (store ((as const (Array E Bool)) false) C true) A true))
+[RECV] ((s0 (store (store ((as const (Array E Bool)) false) C true) B true)))
+[GOOD] (push 1)
+[GOOD] (define-fun s10 () (Array E Bool) (store (store ((as const (Array E Bool)) false) C true) B true))
 [GOOD] (define-fun s11 () Bool (= s0 s10))
 [GOOD] (define-fun s12 () Bool (not s11))
 [GOOD] (assert s12)
-Looking for solution 5
+Fast allSat, Looking for solution 5
 [SEND] (check-sat)
 [RECV] sat
 [SEND] (get-value (s0))
 [RECV] ((s0 (lambda ((x!1 E)) (= x!1 C))))
+[GOOD] (push 1)
 [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)
-Looking for solution 6
+Fast allSat, Looking for solution 6
 [SEND] (check-sat)
 [RECV] sat
 [SEND] (get-value (s0))
-[RECV] ((s0 (lambda ((x!1 E)) (= x!1 B))))
-[GOOD] (define-fun s16 () (Array E Bool) (store ((as const (Array E Bool)) false) B 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) (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)
-Looking for solution 7
+Fast allSat, Looking for solution 7
 [SEND] (check-sat)
 [RECV] sat
 [SEND] (get-value (s0))
-[RECV] ((s0 (store (store ((as const (Array E Bool)) false) C true) B true)))
-[GOOD] (define-fun s19 () (Array E Bool) (store (store ((as const (Array E Bool)) false) C true) B 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) C true) A true))
 [GOOD] (define-fun s20 () Bool (= s0 s19))
 [GOOD] (define-fun s21 () Bool (not s20))
 [GOOD] (assert s21)
-Looking for solution 8
+Fast allSat, Looking for solution 8
 [SEND] (check-sat)
 [RECV] sat
 [SEND] (get-value (s0))
 [RECV] ((s0 (store (store (store ((as const (Array E Bool)) false) C true) B true) A true)))
+[GOOD] (push 1)
 [GOOD] (define-fun s22 () (Array E Bool) (store (store (store ((as const (Array E Bool)) false) C true) B true) A true))
 [GOOD] (define-fun s23 () Bool (= s0 s22))
 [GOOD] (define-fun s24 () Bool (not s23))
 [GOOD] (assert s24)
-Looking for solution 9
+Fast allSat, Looking for solution 9
 [SEND] (check-sat)
 [RECV] unsat
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
+[GOOD] (pop 1)
 *** Solver   : Z3
 *** Exit code: ExitSuccess
 
 FINAL:
 Solution #1:
-  s0 = {} :: {E}
+  s0 = {A,B,C} :: {E}
 Solution #2:
-  s0 = {A} :: {E}
+  s0 = {A,C} :: {E}
 Solution #3:
   s0 = {A,B} :: {E}
 Solution #4:
-  s0 = {A,C} :: {E}
-Solution #5:
   s0 = {C} :: {E}
+Solution #5:
+  s0 = {B,C} :: {E}
 Solution #6:
   s0 = {B} :: {E}
 Solution #7:
-  s0 = {B,C} :: {E}
+  s0 = {A} :: {E}
 Solution #8:
-  s0 = {A,B,C} :: {E}
+  s0 = {} :: {E}
 Found 8 different solutions.
 DONE!
diff --git a/SBVTestSuite/GoldFiles/uiSat_test1.gold b/SBVTestSuite/GoldFiles/uiSat_test1.gold
--- a/SBVTestSuite/GoldFiles/uiSat_test1.gold
+++ b/SBVTestSuite/GoldFiles/uiSat_test1.gold
@@ -89,16 +89,16 @@
 
 RESULT: Solution #1:
   q1 :: Bool -> Bool
-  q1 _ = False
+  q1 True = True 
+  q1 _    = False
 Solution #2:
   q1 :: Bool -> Bool
-  q1 _ = True
-Solution #3:
-  q1 :: Bool -> Bool
   q1 True = False
   q1 _    = True 
+Solution #3:
+  q1 :: Bool -> Bool
+  q1 _ = True
 Solution #4:
   q1 :: Bool -> Bool
-  q1 True = True 
-  q1 _    = False
+  q1 _ = False
 Found 4 different solutions.
diff --git a/SBVTestSuite/GoldFiles/uiSat_test2.gold b/SBVTestSuite/GoldFiles/uiSat_test2.gold
--- a/SBVTestSuite/GoldFiles/uiSat_test2.gold
+++ b/SBVTestSuite/GoldFiles/uiSat_test2.gold
@@ -348,70 +348,70 @@
 
 RESULT: Solution #1:
   q2 :: Bool -> Bool -> Bool
-  q2 _ _ = False
+  q2 True False = False
+  q2 _    _     = True 
 Solution #2:
   q2 :: Bool -> Bool -> Bool
-  q2 _ _ = True
+  q2 True True = False
+  q2 _    _    = True 
 Solution #3:
   q2 :: Bool -> Bool -> Bool
-  q2 False False = False
-  q2 _     _     = True 
+  q2 False False = True 
+  q2 False True  = True 
+  q2 _     _     = False
 Solution #4:
   q2 :: Bool -> Bool -> Bool
-  q2 False True = True 
-  q2 _     _    = False
+  q2 False False = True 
+  q2 True  True  = True 
+  q2 _     _     = False
 Solution #5:
   q2 :: Bool -> Bool -> Bool
-  q2 True True = True 
-  q2 _    _    = False
+  q2 False False = True 
+  q2 _     _     = False
 Solution #6:
   q2 :: Bool -> Bool -> Bool
-  q2 True False = True 
-  q2 True True  = True 
-  q2 _    _     = False
+  q2 True  True = False
+  q2 False True = False
+  q2 _     _    = True 
 Solution #7:
   q2 :: Bool -> Bool -> Bool
-  q2 True False = True 
-  q2 _    _     = False
+  q2 False True = False
+  q2 _     _    = True 
 Solution #8:
   q2 :: Bool -> Bool -> Bool
-  q2 False True  = True 
-  q2 True  False = True 
-  q2 _     _     = False
-Solution #9:
-  q2 :: Bool -> Bool -> Bool
   q2 False True = True 
   q2 True  True = True 
   q2 _     _    = False
+Solution #9:
+  q2 :: Bool -> Bool -> Bool
+  q2 False True  = True 
+  q2 True  False = True 
+  q2 _     _     = False
 Solution #10:
   q2 :: Bool -> Bool -> Bool
-  q2 False True = False
-  q2 _     _    = True 
+  q2 True False = True 
+  q2 _    _     = False
 Solution #11:
   q2 :: Bool -> Bool -> Bool
-  q2 True  True = False
-  q2 False True = False
-  q2 _     _    = True 
+  q2 True False = True 
+  q2 True True  = True 
+  q2 _    _     = False
 Solution #12:
   q2 :: Bool -> Bool -> Bool
-  q2 False False = True 
-  q2 _     _     = False
+  q2 True True = True 
+  q2 _    _    = False
 Solution #13:
   q2 :: Bool -> Bool -> Bool
-  q2 False False = True 
-  q2 True  True  = True 
-  q2 _     _     = False
+  q2 False True = True 
+  q2 _     _    = False
 Solution #14:
   q2 :: Bool -> Bool -> Bool
-  q2 False False = True 
-  q2 False True  = True 
-  q2 _     _     = False
+  q2 False False = False
+  q2 _     _     = True 
 Solution #15:
   q2 :: Bool -> Bool -> Bool
-  q2 True True = False
-  q2 _    _    = True 
+  q2 _ _ = True
 Solution #16:
   q2 :: Bool -> Bool -> Bool
-  q2 True False = False
-  q2 _    _     = True 
+  q2 _ _ = False
 Found 16 different solutions.
diff --git a/SBVTestSuite/GoldFiles/uiSat_test3.gold b/SBVTestSuite/GoldFiles/uiSat_test3.gold
--- a/SBVTestSuite/GoldFiles/uiSat_test3.gold
+++ b/SBVTestSuite/GoldFiles/uiSat_test3.gold
@@ -2063,61 +2063,63 @@
 
 RESULT: Solution #1:
   q1 :: Bool -> Bool
-  q1 _ = False
+  q1 True = False
+  q1 _    = True 
 
   q2 :: Bool -> Bool -> Bool
-  q2 _ _ = False
+  q2 False False = True 
+  q2 False True  = True 
+  q2 _     _     = False
 Solution #2:
   q1 :: Bool -> Bool
   q1 _ = True
 
   q2 :: Bool -> Bool -> Bool
-  q2 _ _ = False
+  q2 False False = True 
+  q2 False True  = True 
+  q2 _     _     = False
 Solution #3:
   q1 :: Bool -> Bool
-  q1 _ = False
+  q1 True = False
+  q1 _    = True 
 
   q2 :: Bool -> Bool -> Bool
   q2 _ _ = True
 Solution #4:
   q1 :: Bool -> Bool
-  q1 _ = False
+  q1 _ = True
 
   q2 :: Bool -> Bool -> Bool
-  q2 True False = False
-  q2 _    _     = True 
+  q2 _ _ = True
 Solution #5:
   q1 :: Bool -> Bool
-  q1 True = True 
-  q1 _    = False
+  q1 _ = True
 
   q2 :: Bool -> Bool -> Bool
   q2 True False = False
   q2 _    _     = True 
 Solution #6:
   q1 :: Bool -> Bool
-  q1 True = True 
-  q1 _    = False
+  q1 True = False
+  q1 _    = True 
 
   q2 :: Bool -> Bool -> Bool
-  q2 False False = True 
-  q2 _     _     = False
+  q2 True False = False
+  q2 _    _     = True 
 Solution #7:
   q1 :: Bool -> Bool
-  q1 True = True 
-  q1 _    = False
+  q1 True = False
+  q1 _    = True 
 
   q2 :: Bool -> Bool -> Bool
   q2 False False = True 
-  q2 True  True  = True 
   q2 _     _     = False
 Solution #8:
   q1 :: Bool -> Bool
-  q1 _ = False
+  q1 _ = True
 
   q2 :: Bool -> Bool -> Bool
   q2 False False = True 
-  q2 True  True  = True 
   q2 _     _     = False
 Solution #9:
   q1 :: Bool -> Bool
@@ -2125,69 +2127,73 @@
   q1 _    = True 
 
   q2 :: Bool -> Bool -> Bool
-  q2 False False = True 
-  q2 True  True  = True 
-  q2 _     _     = False
+  q2 True False = True 
+  q2 True True  = True 
+  q2 _    _     = False
 Solution #10:
   q1 :: Bool -> Bool
-  q1 _ = False
+  q1 True = False
+  q1 _    = True 
 
   q2 :: Bool -> Bool -> Bool
-  q2 False True = False
-  q2 _     _    = True 
+  q2 True False = True 
+  q2 _    _     = False
 Solution #11:
   q1 :: Bool -> Bool
-  q1 True = False
-  q1 _    = True 
+  q1 True = True 
+  q1 _    = False
 
   q2 :: Bool -> Bool -> Bool
-  q2 False True = False
-  q2 _     _    = True 
+  q2 False True  = False
+  q2 False False = False
+  q2 _     _     = True 
 Solution #12:
   q1 :: Bool -> Bool
-  q1 _ = True
+  q1 True = False
+  q1 _    = True 
 
   q2 :: Bool -> Bool -> Bool
-  q2 True  False = False
-  q2 False True  = False
-  q2 _     _     = True 
+  q2 False True = True 
+  q2 True  True = True 
+  q2 _     _    = False
 Solution #13:
   q1 :: Bool -> Bool
-  q1 _ = True
+  q1 True = False
+  q1 _    = True 
 
   q2 :: Bool -> Bool -> Bool
-  q2 False True = False
-  q2 _     _    = True 
+  q2 False True = True 
+  q2 _     _    = False
 Solution #14:
   q1 :: Bool -> Bool
-  q1 True = True 
-  q1 _    = False
+  q1 _ = True
 
   q2 :: Bool -> Bool -> Bool
-  q2 False True = False
-  q2 _     _    = True 
+  q2 False True = True 
+  q2 _     _    = False
 Solution #15:
   q1 :: Bool -> Bool
-  q1 _ = False
+  q1 _ = True
 
   q2 :: Bool -> Bool -> Bool
-  q2 False False = True 
-  q2 _     _     = False
+  q2 True  False = False
+  q2 False False = False
+  q2 _     _     = True 
 Solution #16:
   q1 :: Bool -> Bool
-  q1 _ = False
+  q1 _ = True
 
   q2 :: Bool -> Bool -> Bool
-  q2 False False = True 
-  q2 True  False = True 
-  q2 _     _     = False
+  q2 True  True  = False
+  q2 False False = False
+  q2 _     _     = True 
 Solution #17:
   q1 :: Bool -> Bool
-  q1 True = True 
-  q1 _    = False
+  q1 True = False
+  q1 _    = True 
 
   q2 :: Bool -> Bool -> Bool
-  q2 False False = True 
+  q2 False True  = True 
   q2 True  False = True 
   q2 _     _     = False
 Solution #18:
@@ -2196,74 +2202,70 @@
   q1 _    = True 
 
   q2 :: Bool -> Bool -> Bool
-  q2 False False = True 
-  q2 True  False = True 
-  q2 _     _     = False
+  q2 False False = False
+  q2 _     _     = True 
 Solution #19:
   q1 :: Bool -> Bool
   q1 _ = True
 
   q2 :: Bool -> Bool -> Bool
-  q2 False False = True 
-  q2 True  False = True 
-  q2 _     _     = False
+  q2 False False = False
+  q2 _     _     = True 
 Solution #20:
   q1 :: Bool -> Bool
-  q1 _ = False
+  q1 _ = True
 
   q2 :: Bool -> Bool -> Bool
-  q2 True True = False
-  q2 _    _    = True 
+  q2 True False = True 
+  q2 True True  = True 
+  q2 _    _     = False
 Solution #21:
   q1 :: Bool -> Bool
-  q1 True = True 
-  q1 _    = False
+  q1 _ = True
 
   q2 :: Bool -> Bool -> Bool
-  q2 True True = False
-  q2 _    _    = True 
+  q2 True False = True 
+  q2 _    _     = False
 Solution #22:
   q1 :: Bool -> Bool
-  q1 True = False
-  q1 _    = True 
+  q1 _ = True
 
   q2 :: Bool -> Bool -> Bool
-  q2 True True = False
-  q2 _    _    = True 
+  q2 True True = True 
+  q2 _    _    = False
 Solution #23:
   q1 :: Bool -> Bool
-  q1 _ = True
+  q1 True = False
+  q1 _    = True 
 
   q2 :: Bool -> Bool -> Bool
-  q2 True True = False
-  q2 _    _    = True 
+  q2 True True = True 
+  q2 _    _    = False
 Solution #24:
   q1 :: Bool -> Bool
-  q1 True = True 
-  q1 _    = False
+  q1 True = False
+  q1 _    = True 
 
   q2 :: Bool -> Bool -> Bool
-  q2 _ _ = True
+  q2 _ _ = False
 Solution #25:
   q1 :: Bool -> Bool
-  q1 True = True 
-  q1 _    = False
+  q1 _ = False
 
   q2 :: Bool -> Bool -> Bool
-  q2 True True  = False
-  q2 True False = False
-  q2 _    _     = True 
+  q2 True True = True 
+  q2 _    _    = False
 Solution #26:
   q1 :: Bool -> Bool
   q1 _ = False
 
   q2 :: Bool -> Bool -> Bool
-  q2 True True  = False
-  q2 True False = False
-  q2 _    _     = True 
+  q2 False False = False
+  q2 _     _     = True 
 Solution #27:
   q1 :: Bool -> Bool
-  q1 _ = False
+  q1 True = True 
+  q1 _    = False
 
   q2 :: Bool -> Bool -> Bool
   q2 False True  = True 
@@ -2274,83 +2276,82 @@
   q1 _ = False
 
   q2 :: Bool -> Bool -> Bool
-  q2 True False = True 
-  q2 _    _     = False
+  q2 True  False = False
+  q2 False False = False
+  q2 _     _     = True 
 Solution #29:
   q1 :: Bool -> Bool
   q1 True = True 
   q1 _    = False
 
   q2 :: Bool -> Bool -> Bool
-  q2 _ _ = False
+  q2 True  False = False
+  q2 False False = False
+  q2 _     _     = True 
 Solution #30:
   q1 :: Bool -> Bool
-  q1 True = True 
-  q1 _    = False
+  q1 _ = False
 
   q2 :: Bool -> Bool -> Bool
-  q2 False True = True 
-  q2 _     _    = False
+  q2 False True  = False
+  q2 False False = False
+  q2 _     _     = True 
 Solution #31:
   q1 :: Bool -> Bool
-  q1 True = True 
-  q1 _    = False
+  q1 _ = False
 
   q2 :: Bool -> Bool -> Bool
-  q2 False False = False
-  q2 _     _     = True 
+  q2 False True = True 
+  q2 _     _    = False
 Solution #32:
   q1 :: Bool -> Bool
   q1 True = True 
   q1 _    = False
 
   q2 :: Bool -> Bool -> Bool
-  q2 True True = True 
-  q2 _    _    = False
+  q2 True False = True 
+  q2 _    _     = False
 Solution #33:
   q1 :: Bool -> Bool
   q1 True = True 
   q1 _    = False
 
   q2 :: Bool -> Bool -> Bool
-  q2 True False = True 
-  q2 _    _     = False
+  q2 True True = True 
+  q2 _    _    = False
 Solution #34:
   q1 :: Bool -> Bool
-  q1 _ = False
+  q1 True = True 
+  q1 _    = False
 
   q2 :: Bool -> Bool -> Bool
-  q2 False True = True 
-  q2 _     _    = False
+  q2 False False = False
+  q2 _     _     = True 
 Solution #35:
   q1 :: Bool -> Bool
-  q1 _ = False
+  q1 True = True 
+  q1 _    = False
 
   q2 :: Bool -> Bool -> Bool
-  q2 False True  = False
-  q2 False False = False
-  q2 _     _     = True 
+  q2 False True = True 
+  q2 _     _    = False
 Solution #36:
   q1 :: Bool -> Bool
   q1 True = True 
   q1 _    = False
 
   q2 :: Bool -> Bool -> Bool
-  q2 True  False = False
-  q2 False False = False
-  q2 _     _     = True 
+  q2 _ _ = False
 Solution #37:
   q1 :: Bool -> Bool
   q1 _ = False
 
   q2 :: Bool -> Bool -> Bool
-  q2 True  False = False
-  q2 False False = False
-  q2 _     _     = True 
+  q2 True False = True 
+  q2 _    _     = False
 Solution #38:
   q1 :: Bool -> Bool
-  q1 True = True 
-  q1 _    = False
+  q1 _ = False
 
   q2 :: Bool -> Bool -> Bool
   q2 False True  = True 
@@ -2361,182 +2362,186 @@
   q1 _ = False
 
   q2 :: Bool -> Bool -> Bool
-  q2 False False = False
-  q2 _     _     = True 
+  q2 True True  = False
+  q2 True False = False
+  q2 _    _     = True 
 Solution #40:
   q1 :: Bool -> Bool
-  q1 _ = False
+  q1 True = True 
+  q1 _    = False
 
   q2 :: Bool -> Bool -> Bool
-  q2 True True = True 
-  q2 _    _    = False
+  q2 True True  = False
+  q2 True False = False
+  q2 _    _     = True 
 Solution #41:
   q1 :: Bool -> Bool
-  q1 True = False
-  q1 _    = True 
+  q1 True = True 
+  q1 _    = False
 
   q2 :: Bool -> Bool -> Bool
-  q2 _ _ = False
+  q2 _ _ = True
 Solution #42:
   q1 :: Bool -> Bool
-  q1 True = False
-  q1 _    = True 
+  q1 _ = True
 
   q2 :: Bool -> Bool -> Bool
-  q2 True True = True 
-  q2 _    _    = False
+  q2 True True = False
+  q2 _    _    = True 
 Solution #43:
   q1 :: Bool -> Bool
-  q1 _ = True
+  q1 True = False
+  q1 _    = True 
 
   q2 :: Bool -> Bool -> Bool
-  q2 True True = True 
-  q2 _    _    = False
+  q2 True True = False
+  q2 _    _    = True 
 Solution #44:
   q1 :: Bool -> Bool
-  q1 _ = True
+  q1 True = True 
+  q1 _    = False
 
   q2 :: Bool -> Bool -> Bool
-  q2 True False = True 
-  q2 _    _     = False
+  q2 True True = False
+  q2 _    _    = True 
 Solution #45:
   q1 :: Bool -> Bool
-  q1 _ = True
+  q1 _ = False
 
   q2 :: Bool -> Bool -> Bool
-  q2 True False = True 
-  q2 True True  = True 
-  q2 _    _     = False
+  q2 True True = False
+  q2 _    _    = True 
 Solution #46:
   q1 :: Bool -> Bool
   q1 _ = True
 
   q2 :: Bool -> Bool -> Bool
-  q2 False False = False
-  q2 _     _     = True 
+  q2 False False = True 
+  q2 True  False = True 
+  q2 _     _     = False
 Solution #47:
   q1 :: Bool -> Bool
   q1 True = False
   q1 _    = True 
 
   q2 :: Bool -> Bool -> Bool
-  q2 False False = False
-  q2 _     _     = True 
+  q2 False False = True 
+  q2 True  False = True 
+  q2 _     _     = False
 Solution #48:
   q1 :: Bool -> Bool
-  q1 True = False
-  q1 _    = True 
+  q1 True = True 
+  q1 _    = False
 
   q2 :: Bool -> Bool -> Bool
-  q2 False True  = True 
+  q2 False False = True 
   q2 True  False = True 
   q2 _     _     = False
 Solution #49:
   q1 :: Bool -> Bool
-  q1 _ = True
+  q1 _ = False
 
   q2 :: Bool -> Bool -> Bool
-  q2 True  True  = False
-  q2 False False = False
-  q2 _     _     = True 
+  q2 False False = True 
+  q2 True  False = True 
+  q2 _     _     = False
 Solution #50:
   q1 :: Bool -> Bool
-  q1 _ = True
+  q1 _ = False
 
   q2 :: Bool -> Bool -> Bool
-  q2 True  False = False
-  q2 False False = False
-  q2 _     _     = True 
+  q2 False False = True 
+  q2 _     _     = False
 Solution #51:
   q1 :: Bool -> Bool
-  q1 _ = True
+  q1 True = True 
+  q1 _    = False
 
   q2 :: Bool -> Bool -> Bool
-  q2 False True = True 
-  q2 _     _    = False
+  q2 False True = False
+  q2 _     _    = True 
 Solution #52:
   q1 :: Bool -> Bool
-  q1 True = False
-  q1 _    = True 
+  q1 _ = True
 
   q2 :: Bool -> Bool -> Bool
-  q2 False True = True 
-  q2 _     _    = False
+  q2 False True = False
+  q2 _     _    = True 
 Solution #53:
   q1 :: Bool -> Bool
-  q1 True = False
-  q1 _    = True 
+  q1 _ = True
 
   q2 :: Bool -> Bool -> Bool
-  q2 False True = True 
-  q2 True  True = True 
-  q2 _     _    = False
+  q2 True  False = False
+  q2 False True  = False
+  q2 _     _     = True 
 Solution #54:
   q1 :: Bool -> Bool
-  q1 True = True 
-  q1 _    = False
+  q1 True = False
+  q1 _    = True 
 
   q2 :: Bool -> Bool -> Bool
-  q2 False True  = False
-  q2 False False = False
-  q2 _     _     = True 
+  q2 False True = False
+  q2 _     _    = True 
 Solution #55:
   q1 :: Bool -> Bool
-  q1 True = False
-  q1 _    = True 
+  q1 _ = False
 
   q2 :: Bool -> Bool -> Bool
-  q2 True False = True 
-  q2 _    _     = False
+  q2 False True = False
+  q2 _     _    = True 
 Solution #56:
   q1 :: Bool -> Bool
   q1 True = False
   q1 _    = True 
 
   q2 :: Bool -> Bool -> Bool
-  q2 True False = True 
-  q2 True True  = True 
-  q2 _    _     = False
+  q2 False False = True 
+  q2 True  True  = True 
+  q2 _     _     = False
 Solution #57:
   q1 :: Bool -> Bool
-  q1 _ = True
+  q1 _ = False
 
   q2 :: Bool -> Bool -> Bool
   q2 False False = True 
+  q2 True  True  = True 
   q2 _     _     = False
 Solution #58:
   q1 :: Bool -> Bool
-  q1 True = False
-  q1 _    = True 
+  q1 True = True 
+  q1 _    = False
 
   q2 :: Bool -> Bool -> Bool
   q2 False False = True 
+  q2 True  True  = True 
   q2 _     _     = False
 Solution #59:
   q1 :: Bool -> Bool
-  q1 True = False
-  q1 _    = True 
+  q1 True = True 
+  q1 _    = False
 
   q2 :: Bool -> Bool -> Bool
-  q2 True False = False
-  q2 _    _     = True 
+  q2 False False = True 
+  q2 _     _     = False
 Solution #60:
   q1 :: Bool -> Bool
-  q1 _ = True
+  q1 True = True 
+  q1 _    = False
 
   q2 :: Bool -> Bool -> Bool
   q2 True False = False
   q2 _    _     = True 
 Solution #61:
   q1 :: Bool -> Bool
-  q1 _ = True
+  q1 _ = False
 
   q2 :: Bool -> Bool -> Bool
-  q2 _ _ = True
+  q2 True False = False
+  q2 _    _     = True 
 Solution #62:
   q1 :: Bool -> Bool
-  q1 True = False
-  q1 _    = True 
+  q1 _ = False
 
   q2 :: Bool -> Bool -> Bool
   q2 _ _ = True
@@ -2545,16 +2550,11 @@
   q1 _ = True
 
   q2 :: Bool -> Bool -> Bool
-  q2 False False = True 
-  q2 False True  = True 
-  q2 _     _     = False
+  q2 _ _ = False
 Solution #64:
   q1 :: Bool -> Bool
-  q1 True = False
-  q1 _    = True 
+  q1 _ = False
 
   q2 :: Bool -> Bool -> Bool
-  q2 False False = True 
-  q2 False True  = True 
-  q2 _     _     = False
+  q2 _ _ = False
 Found 64 different solutions.
diff --git a/SBVTestSuite/GoldFiles/uninterpreted-3a.gold b/SBVTestSuite/GoldFiles/uninterpreted-3a.gold
--- a/SBVTestSuite/GoldFiles/uninterpreted-3a.gold
+++ b/SBVTestSuite/GoldFiles/uninterpreted-3a.gold
@@ -60,13 +60,13 @@
 *** Exit code: ExitSuccess
 
  FINAL:Solution #1:
-  p =  True :: Bool
-  q = False :: Bool
+  p = True :: Bool
+  q = True :: Bool
 Solution #2:
   p = False :: Bool
   q =  True :: Bool
 Solution #3:
-  p = True :: Bool
-  q = True :: Bool
+  p =  True :: Bool
+  q = False :: Bool
 Found 3 different solutions.
 DONE!
diff --git a/SBVTestSuite/TestSuite/Basics/AllSat.hs b/SBVTestSuite/TestSuite/Basics/AllSat.hs
--- a/SBVTestSuite/TestSuite/Basics/AllSat.hs
+++ b/SBVTestSuite/TestSuite/Basics/AllSat.hs
@@ -20,6 +20,7 @@
 
 import Utils.SBVTestFramework
 
+import Control.Monad(void)
 import Data.List (sortOn)
 
 data Q
@@ -34,6 +35,7 @@
     , goldenVsStringShow "allSat4" $            allSat $ \x -> x .<  (0::SWord8)
     , goldenVsStringShow "allSat5" $ fmap srt $ allSat $ \x y -> x .< y .&& y .< (4::SWord8)
     , goldenVsStringShow "allSat6" $            allSat $ exists "x" >>= \x -> exists "y" >>= \y -> forall "z" >>= \z -> return (x .< (y::SWord8) .&& y .< 3 .&& z .== (z::SWord8))
+    , goldenCapturedIO   "allSat7" $ \rf -> void (allSatWith z3{verbose=True, redirectVerbose=Just rf} t3)
     ]
 
 srt :: AllSatResult -> AllSatResult
@@ -49,3 +51,16 @@
                  y <- free "y"
                  z <- free "z"
                  return $ x .== (y :: SQ) .&& z .== (z :: SQ)
+
+t3 :: Goal
+t3 = do x <- sInteger "x"
+        y <- sInteger "y"
+        z <- sInteger "z"
+
+        let range = (1, 15)
+
+        constrain $ x `inRange` range
+        constrain $ y `inRange` range
+        constrain $ z `inRange` range
+
+        constrain $ distinct [x, y, z]
diff --git a/sbv.cabal b/sbv.cabal
--- a/sbv.cabal
+++ b/sbv.cabal
@@ -1,7 +1,7 @@
 Cabal-Version: 2.2
 
 Name        : sbv
-Version     : 8.12
+Version     : 8.13
 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
@@ -85,10 +85,11 @@
                   , Data.SBV.Internals
                   , Data.SBV.List
                   , Data.SBV.Maybe
+                  , Data.SBV.Rational
                   , Data.SBV.Set
+                  , Data.SBV.Char
                   , Data.SBV.String
                   , Data.SBV.Tuple
-                  , Data.SBV.Char
                   , Data.SBV.RegExp
                   , Data.SBV.Tools.BMC
                   , Data.SBV.Tools.BoundedList