diff --git a/CHANGES.md b/CHANGES.md --- a/CHANGES.md +++ b/CHANGES.md @@ -1,6 +1,48 @@ * Hackage: * GitHub: +### Version 11.1, 2025-02-21 + + * Completely reworked KnuckleDragger interfaces and proof styles, adding calculational and induction + based proof strategies. SBV can now prove many inductive theorems in this mode, where the user guides + the SMT solver to find tricky proofs. See Documentation/SBV/Examples/KnuckleDragger directory for many + examples demonstrating the new features. + + * Generalize support for polyorphic and higher-order functions. These are still experimental, as SMTLib's + higher-order function support is nascent. (Version 3 of SMTLib will have proper support for such functions, which + is not released yet.) Currently, SBV can handle polymorphic and higher-order usage of: 'reverse', 'any', 'all', + 'filter', 'map', 'foldl', 'foldr', 'zip', and 'zipWith'; all exported from the 'Data.SBV.List' module. + These functions are supported polymporphically, and (except reverse and zip) all take a function as + an argument. SBV firstifies these functions, and the resulting code is compatible with Z3 and CVC5. + (Firstification might change in the future, as SMTLib gains support for more higher-order + features itself.) Proof-support in backend solvers for higher-order functions is still quite weak, + though KnuckleDragger makes things easier. + + * Generalize the signatures of the default project-embed implementations of the Queriable class. + + * [BACKWARDS COMPATIBILITY] Removed rarely used functions mapi, foldli, foldri from Data.SBV.List. These + can now be defined by the user as we have proper support for fold and map using lambdas. + + * [BACKWARDS COMPATIBILITY] Removed "Data/SBV/Tools/BoundedFix.hs", and "Data/SBV/Tools/BoundedList.hs", which + were relatively unused and are more or less obsolete with SBV's new support for sequences and recursive + functions. If you were using these functions you could easily recreate them. Please get in touch if you + need this old functionality. + + * [BACKWARDS COMPATIBILITY] Data.SBV no longer exports the class SatModel, which is more directed + towards internal SBV purposes. If you need it, you can now import it from Data.SBV.Internals. + + * [BACKWARDS COMPATIBILITY] Added 'registerFunction' which comes in handy for telling SBV about functions + that are used in query mode. This is typically not necessary as SBV will register them automatically, but + there are certain scenarios where explicit control is needed. This function also generalizes the old + 'registerUISMTFunction', which was a special case of this function and is now removed. + + * [BACKWARDS COMPATIBILITY] The function 'registerSMTType' is renamed to 'registerType'. + + * Fix the time-out limit setting for CVC4/5. Thanks to Daniel Matichuk for reporting. + + * Fix a performance issue with nested-lambda/quantifiers. Thanks to Blake C. Rawlings for reporting and + Jeff Young for analysis. + ### Version 11.0, 2024-11-06 * [BACKWARDS COMPATIBILITY] SBV now handles arrays in a much more uniform way, unifying diff --git a/COPYRIGHT b/COPYRIGHT --- a/COPYRIGHT +++ b/COPYRIGHT @@ -1,4 +1,4 @@ -Copyright (c) 2010-2024, Levent Erkok (erkokl@gmail.com) +Copyright (c) 2010-2025, Levent Erkok (erkokl@gmail.com) All rights reserved. The sbv library is distributed with the BSD3 license. See the LICENSE file diff --git a/Data/SBV.hs b/Data/SBV.hs --- a/Data/SBV.hs +++ b/Data/SBV.hs @@ -312,7 +312,7 @@ , mkUninterpretedSort -- * Stopping unrolling: Defined functions - , SMTDefinable(..) + , SMTDefinable(..), registerType -- * Special relations -- $specialRels @@ -401,11 +401,11 @@ -- ** Programmable model extraction -- $programmableExtraction - , SatModel(..), Modelable(..), displayModels, extractModels + , Modelable(..), displayModels, extractModels , getModelDictionaries, getModelValues, getModelUninterpretedValues -- * SMT Interface - , SMTConfig(..), Timing(..), SMTLibVersion(..), Solver(..), SMTSolver(..) + , SMTConfig(..), KDOptions(..), Timing(..), SMTLibVersion(..), Solver(..), SMTSolver(..) -- ** Controlling verbosity -- $verbosity @@ -422,6 +422,7 @@ , SymVal, free, free_, mkFreeVars, symbolic, symbolics, literal, unliteral, fromCV , isConcrete, isSymbolic, isConcretely, mkSymVal , MonadSymbolic(..), Symbolic, SymbolicT, label, output, runSMT, runSMTWith + , some -- * Queriable values , Queriable(..), freshVar, freshVar_, getValue @@ -435,7 +436,7 @@ , module Data.Ratio ) where -import Control.Monad (when) +import Control.Monad (unless) import Control.Monad.Trans (MonadIO) import Data.SBV.Core.AlgReals @@ -470,7 +471,7 @@ import Data.SBV.Core.Floating import Data.SBV.Core.Symbolic ( MonadSymbolic(..), SymbolicT, registerKind , ProgInfo(..), rProgInfo, SpecialRelOp(..), UICodeKind(UINone) - , getRootState + , getRootState, UIName(UIGiven) ) import Data.SBV.Provers.Prover hiding (prove, proveWith, sat, satWith, allSat, @@ -1196,10 +1197,10 @@ return $ observe "Expected" spec .== observe "Result" res :} Falsifiable. Counter-example: - Expected = 34 :: Word8 - Result = 1 :: Word8 i1 = 12 :: Word8 i2 = 22 :: Word8 + Expected = 34 :: Word8 + Result = 1 :: Word8 The 'observeIf' variant allows the user to specify a boolean condition when the value is interesting to observe. Useful when you have lots of "debugging" points, but not all are of interest. Use the 'sObserve' variant when you are at the 'Symbolic' @@ -1310,15 +1311,15 @@ Q.E.D. >>> prove $ roundTrip @Int32 Falsifiable. Counter-example: - s0 = RoundTowardNegative :: RoundingMode - s1 = -536873931 :: Int32 + s0 = RoundTowardPositive :: RoundingMode + s1 = 1104019333 :: Int32 Note how we get a failure on `Int32`. The counter-example value is not representable exactly as a single precision float: ->>> toRational (-536873931 :: Float) -(-536873920) % 1 +>>> toRational (1104019333 :: Float) +1104019328 % 1 -Note how the numerator is different, it is off by 11. This is hardly surprising, since floats become sparser as +Note how the numerator is different, it is off by 5. This is hardly surprising, since floats become sparser as the magnitude increases to be able to cover all the integer values representable. >>> :{ @@ -1341,15 +1342,15 @@ >>> prove $ roundTrip @Int64 Falsifiable. Counter-example: s0 = RoundNearestTiesToEven :: RoundingMode - s1 = -9223372036854775538 :: Int64 + s1 = -2305843042984656748 :: Int64 Just like in the `SFloat` case, once we reach 64-bits, we no longer can exactly represent the integer value for all possible values: ->>> toRational (fromIntegral (-9223372036854775538 :: Int64) :: Double) -(-9223372036854775808) % 1 +>>> toRational (fromIntegral (-2305843042984656748 :: Int64) :: Double) +(-2305843042984656896) % 1 -In this case the numerator is off by 270. +In this case the numerator is off by 148. -} -- | An implementation of rotate-left, using a barrel shifter like design. Only works when both @@ -1672,7 +1673,7 @@ where result st = do -- Is this new? If so create it, otherwise reuse ProgInfo{progTransClosures = curProgTransClosures} <- readIORef (rProgInfo st) - when (key `notElem` curProgTransClosures) $ do + unless (key `elem` curProgTransClosures) $ do registerKind st ka @@ -1706,16 +1707,16 @@ -- Is this new? If so create it, otherwise reuse ProgInfo{progSpecialRels = curSpecialRels} <- readIORef (rProgInfo st) - when (op `notElem` curSpecialRels) $ do + unless (op `elem` curSpecialRels) $ do registerKind st ka - newUninterpreted st (nm, Nothing) (SBVType [ka, ka, KBool]) (UINone True) + nm' <- newUninterpreted st (UIGiven nm) Nothing (SBVType [ka, ka, KBool]) (UINone True) -- Add to the end so if we get incremental ones the order doesn't change for old ones! modifyIORef' (rProgInfo st) (\u -> u{progSpecialRels = curSpecialRels ++ [iop]}) -- Equate it to the relation we are given. We want to do this in the parent state - let SBV eq = quantifiedBool $ \(Forall x) (Forall y) -> rel (x, y) .== uninterpret nm x y + let SBV eq = quantifiedBool $ \(Forall x) (Forall y) -> rel (x, y) .== uninterpret nm' x y internalConstraint (getRootState st) False [] eq newExpr st KBool $ SBVApp (SpecialRelOp ka iop) [] @@ -1776,14 +1777,16 @@ -- via the 'QueryT' monad transformer. embed :: QueryResult a -> QueryT m a - default project :: (a ~ t (SBV e), QueryResult a ~ t e, Traversable t, MonadIO m, SymVal e) => a -> QueryT m (QueryResult a) + default project :: (a ~ t e, QueryResult (t e) ~ t (QueryResult e), Traversable t, Monad m, Queriable m e) => a -> QueryT m (QueryResult a) project = mapM project - default embed :: (a ~ t (SBV e), QueryResult a ~ t e, Traversable t, MonadIO m, SymVal e) => QueryResult a -> QueryT m a + default embed :: (a ~ t e, QueryResult (t e) ~ t (QueryResult e), Traversable t, Monad m, Queriable m e) => QueryResult a -> QueryT m a embed = mapM embed {-# MINIMAL create #-} --- | Generic 'Queriable' instance for 'SymVal' values +-- | Generic 'Queriable' instance for 'SymVal' values. This provides the base case for the generic definitions for project and embed +-- when we automatically derive them. We make this instance overlappable should the user have a different mapping in mind, for instance +-- mapping a symbolic boolean to a concrete integer for whatever reason. instance {-# OVERLAPPABLE #-} (MonadIO m, SymVal a) => Queriable m (SBV a) where type QueryResult (SBV a) = a 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 @@ -726,11 +726,11 @@ -- In C, the second argument is returned. (I think, might depend on the architecture, optimizations etc.). -- We'll translate it so that we deterministically return +0. -- There's really no good choice here. - wrapMinMax k a b s = parens cond <+> text "?" <+> zero <+> text ":" <+> s - where zero = text $ if k == KFloat then showCFloat 0 else showCDouble 0 - cond = parens (text "FP_ZERO == fpclassify" P.<> parens a) -- a is zero - <+> text "&&" <+> parens (text "FP_ZERO == fpclassify" P.<> parens b) -- b is zero - <+> text "&&" <+> parens (text "signbit" P.<> parens a <+> text "!=" <+> text "signbit" P.<> parens b) -- a and b differ in sign + wrapMinMax k a b s = parens cond <+> text "?" <+> fzero <+> text ":" <+> s + where fzero = text $ if k == KFloat then showCFloat 0 else showCDouble 0 + cond = parens (text "FP_ZERO == fpclassify" P.<> parens a) -- a is zero + <+> text "&&" <+> parens (text "FP_ZERO == fpclassify" P.<> parens b) -- b is zero + <+> text "&&" <+> parens (text "signbit" P.<> parens a <+> text "!=" <+> text "signbit" P.<> parens b) -- a and b differ in sign ppExpr :: CgConfig -> [(SV, CV)] -> SBVExpr -> Doc -> (Doc, Doc) -> Doc ppExpr cfg consts (SBVApp op opArgs) lhs (typ, var) diff --git a/Data/SBV/Control.hs b/Data/SBV/Control.hs --- a/Data/SBV/Control.hs +++ b/Data/SBV/Control.hs @@ -22,7 +22,7 @@ -- * Querying the solver -- ** Extracting values - , registerUISMTFunction, registerSMTType, getFunction, getUninterpretedValue, getModel, getAssignment, getSMTResult, getUnknownReason, getObservables + , getFunction, getUninterpretedValue, getModel, getAssignment, getSMTResult, getUnknownReason, getObservables -- ** Extracting the unsat core , getUnsatCore @@ -74,7 +74,6 @@ import Data.SBV.Core.Symbolic (Symbolic, QueryContext(..)) import Data.SBV.Trans.Control hiding (query) -import Data.SBV.Control.Utils (registerUISMTFunction, registerSMTType) import qualified Data.SBV.Control.Utils as Trans 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 @@ -61,23 +61,22 @@ import Data.SBV.Control.Types import Data.SBV.Control.Utils +import Data.SBV.Utils.Lib (unBar) import Data.SBV.Utils.PrettyNum (showNegativeNumber) -- | An Assignment of a model binding data Assignment = Assign SVal CV --- Remove one pair of surrounding 'c's, if present -noSurrounding :: Char -> String -> String -noSurrounding c (c':cs@(_:_)) | c == c' && c == last cs = init cs -noSurrounding _ s = s - --- Remove a pair of surrounding quotes -unQuote :: String -> String -unQuote = noSurrounding '"' - --- Remove a pair of surrounding bars -unBar :: String -> String -unBar = noSurrounding '|' +-- | Remove the bars from model names; these are (mostly!) automatically inserted +unBarModel :: SMTModel -> SMTModel +unBarModel SMTModel {modelObjectives, modelBindings, modelAssocs, modelUIFuns} + = SMTModel { modelObjectives = ubf <$> modelObjectives + , modelBindings = (ubn <$>) <$> modelBindings + , modelAssocs = ubf <$> modelAssocs + , modelUIFuns = ubf <$> modelUIFuns + } + where ubf (n, a) = (unBar n, a) + ubn (NamedSymVar sv nm, a) = (NamedSymVar sv (T.pack (unBar (T.unpack nm))), a) -- Is this a string? If so, return it, otherwise fail in the Maybe monad. fromECon :: SExpr -> Maybe String @@ -173,7 +172,8 @@ ReproducibleResourceLimit{} -> askFor "ReproducibleResourceLimit" ":reproducible-resource-limit" $ integer ReproducibleResourceLimit SMTVerbosity{} -> askFor "SMTVerbosity" ":verbosity" $ integer SMTVerbosity OptionKeyword nm _ -> askFor ("OptionKeyword" ++ nm) nm $ stringList (OptionKeyword nm) - SetLogic{} -> error "Data.SBV.Query: SMTLib does not allow querying value of the logic!" + SetLogic{} -> error "Data.SBV.Query: SMTLib does not allow querying the value of logic!" + SetTimeOut{} -> error "Data.SBV.Query: SMTLib does not allow querying the timeout value!" -- Not to be confused by getInfo, which is totally irrelevant! SetInfo{} -> error "Data.SBV.Query: SMTLib does not allow querying value of meta-info!" @@ -320,14 +320,13 @@ allModelInputs <- getTopLevelInputs obsvs <- getObservables - inputAssocs <- let grab (NamedSymVar sv nm) = let wrap !c = (sv, (nm, c)) in wrap <$> getValueCV mbi sv in mapM grab allModelInputs let name = fst . snd removeSV = snd prepare = S.unstableSort . S.filter (not . mustIgnoreVar cfg . T.unpack . name) - assocs = S.fromList (sortOn fst obsvs) <> fmap removeSV (prepare inputAssocs) + assocs = fmap removeSV (prepare inputAssocs) <> S.fromList (sortOn fst obsvs) -- collect UIs, and UI functions if requested let uiFuns = [ui | ui@(nm, (_, _, SBVType as)) <- uis, length as > 1, allSatTrackUFs cfg, not (mustIgnoreVar cfg nm)] -- functions have at least two things in their type! @@ -354,11 +353,11 @@ uiVals <- mapM (\ui@(nm, (_, _, _)) -> (nm,) <$> getUICVal mbi ui) uiRegs - return SMTModel { modelObjectives = [] - , modelBindings = toList <$> bindings - , modelAssocs = uiVals ++ toList (first T.unpack <$> assocs) - , modelUIFuns = uiFunVals - } + return $ unBarModel $ SMTModel { modelObjectives = [] + , modelBindings = toList <$> bindings + , modelAssocs = uiVals ++ toList (first T.unpack <$> assocs) + , modelUIFuns = uiFunVals + } -- | Just after a check-sat is issued, collect objective values. Used -- internally only, not exposed to the user. diff --git a/Data/SBV/Control/Types.hs b/Data/SBV/Control/Types.hs --- a/Data/SBV/Control/Types.hs +++ b/Data/SBV/Control/Types.hs @@ -9,12 +9,15 @@ -- Types related to interactive queries ----------------------------------------------------------------------------- +{-# LANGUAGE DeriveAnyClass #-} +{-# LANGUAGE DeriveGeneric #-} + {-# OPTIONS_GHC -Wall -Werror #-} module Data.SBV.Control.Types ( CheckSatResult(..) , Logic(..) - , SMTOption(..), isStartModeOption, isOnlyOnceOption, setSMTOption + , SMTOption(..), isStartModeOption, isOnlyOnceOption , SMTInfoFlag(..) , SMTErrorBehavior(..) , SMTReasonUnknown(..) @@ -22,13 +25,14 @@ ) where import Control.DeepSeq (NFData(..)) +import GHC.Generics (Generic) -- | Result of a 'Data.SBV.Control.checkSat' or 'Data.SBV.Control.checkSatAssuming' call. data CheckSatResult = Sat -- ^ Satisfiable: A model is available, which can be queried with 'Data.SBV.Control.getValue'. | DSat (Maybe String) -- ^ Delta-satisfiable: A delta-sat model is available. String is the precision info, if available. | Unsat -- ^ Unsatisfiable: No model is available. Unsat cores might be obtained via 'Data.SBV.Control.getUnsatCore'. | Unk -- ^ Unknown: Use 'Data.SBV.Control.getUnknownReason' to obtain an explanation why this might be the case. - deriving (Eq, Show) + deriving (Eq, Show, NFData, Generic) -- | Collectable information from the solver. data SMTInfoFlag = AllStatistics @@ -112,6 +116,7 @@ | OptionKeyword String [String] | SetLogic Logic | SetInfo String [String] + | SetTimeOut Integer deriving Show -- | Can this command only be run at the very beginning? If 'True' then @@ -132,6 +137,7 @@ isStartModeOption OptionKeyword{} = True -- Conservative. isStartModeOption SetLogic{} = True isStartModeOption SetInfo{} = False +isStartModeOption SetTimeOut{} = True -- | Can this option be set multiple times? I'm only making a guess here. -- If this returns True, then we'll only send the last instance we see. @@ -151,35 +157,7 @@ isOnlyOnceOption OptionKeyword{} = False -- This is really hard to determine. Just being permissive isOnlyOnceOption SetLogic{} = True isOnlyOnceOption SetInfo{} = False - --- SMTLib's True/False is spelled differently than Haskell's. -smtBool :: Bool -> String -smtBool True = "true" -smtBool False = "false" - --- | Translate an option setting to SMTLib. Note the SetLogic/SetInfo discrepancy. -setSMTOption :: SMTOption -> String -setSMTOption = cvt - where cvt (DiagnosticOutputChannel f) = opt [":diagnostic-output-channel", show f] - cvt (ProduceAssertions b) = opt [":produce-assertions", smtBool b] - cvt (ProduceAssignments b) = opt [":produce-assignments", smtBool b] - cvt (ProduceProofs b) = opt [":produce-proofs", smtBool b] - cvt (ProduceInterpolants b) = opt [":produce-interpolants", smtBool b] - cvt (ProduceUnsatAssumptions b) = opt [":produce-unsat-assumptions", smtBool b] - cvt (ProduceUnsatCores b) = opt [":produce-unsat-cores", smtBool b] - cvt (ProduceAbducts b) = opt [":produce-abducts", smtBool b] - cvt (RandomSeed i) = opt [":random-seed", show i] - cvt (ReproducibleResourceLimit i) = opt [":reproducible-resource-limit", show i] - cvt (SMTVerbosity i) = opt [":verbosity", show i] - cvt (OptionKeyword k as) = opt (k : as) - cvt (SetLogic l) = logic l - cvt (SetInfo k as) = info (k : as) - - opt xs = "(set-option " ++ unwords xs ++ ")" - info xs = "(set-info " ++ unwords xs ++ ")" - - logic Logic_NONE = "; NB. not setting the logic per user request of Logic_NONE" - logic l = "(set-logic " ++ show l ++ ")" +isOnlyOnceOption SetTimeOut{} = False -- | SMT-Lib logics. If left unspecified SBV will pick the logic based on what it determines is needed. However, the -- user can override this choice using a call to 'Data.SBV.setLogic' This is especially handy if one is experimenting with custom 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 @@ -10,6 +10,7 @@ ----------------------------------------------------------------------------- {-# LANGUAGE BangPatterns #-} +{-# LANGUAGE InstanceSigs #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE FunctionalDependencies #-} @@ -29,8 +30,7 @@ io , ask, send, getValue, getFunction, getUninterpretedValue , getValueCV, getUICVal, getUIFunCVAssoc, getUnsatAssumptions - , SMTFunction(..), registerUISMTFunction, registerSMTType - , getQueryState, modifyQueryState, getConfig, getObjectives, getUIs + , SMTFunction(..), getQueryState, modifyQueryState, getConfig, getObjectives, getUIs , getSBVAssertions, getSBVPgm, getObservables , checkSat, checkSatUsing, getAllSatResult , inNewContext, freshVar, freshVar_ @@ -78,10 +78,10 @@ , MonadQuery(..), QueryContext(..), VarContext(..) , registerLabel, svMkSymVar, validationRequested , isSafetyCheckingIStage, isSetupIStage, isRunIStage, IStage(..), QueryT(..) - , extractSymbolicSimulationState, MonadSymbolic(..), newUninterpreted + , extractSymbolicSimulationState, MonadSymbolic(..) , UserInputs, getSV, NamedSymVar(..), lookupInput, getUserName' - , Name, CnstMap, UICodeKind(UINone), smtDefGivenName, Inputs(..), ProgInfo(..) - , mustIgnoreVar, registerKind + , Name, CnstMap, smtDefGivenName, Inputs(..), ProgInfo(..) + , mustIgnoreVar, newInternalVariable ) import Data.SBV.Core.AlgReals (mergeAlgReals, AlgReal(..), RealPoint(..)) @@ -91,7 +91,11 @@ import Data.SBV.SMT.SMT (showModel, parseCVs, SatModel, AllSatResult(..)) import Data.SBV.SMT.SMTLib (toIncSMTLib, toSMTLib) -import Data.SBV.SMT.Utils (showTimeoutValue, addAnnotations, alignPlain, debug, mergeSExpr, SBVException(..)) +import Data.SBV.SMT.SMTLib2 (setSMTOption) +import Data.SBV.SMT.Utils ( showTimeoutValue, addAnnotations, alignPlain, debug + , mergeSExpr, SBVException(..), recordTranscript, TranscriptMsg(..) + , witnessName + ) import Data.SBV.Utils.ExtractIO import Data.SBV.Utils.Lib (qfsToString) @@ -115,12 +119,18 @@ contextState = queryState + internalVariable :: forall a. Kind -> QueryT m (SBV a) + internalVariable k = contextState >>= \st -> liftIO $ do + sv <- newInternalVariable st k + pure $ SBV $ SVal k (Right (cache (const (pure sv)))) + setOption o | isStartModeOption o = error $ unlines [ "" , "*** Data.SBV: '" ++ show o ++ "' can only be set at start-up time." , "*** Hint: Move the call to 'setOption' before the query." ] - | True = send True $ setSMTOption o + | True = do State{stCfg} <- contextState + send True $ setSMTOption stCfg o -- | Adding a constraint, possibly with attributes and possibly soft. Only used internally. -- Use 'constrain' and 'namedConstraint' from user programs. @@ -181,6 +191,7 @@ let cnsts = sortBy cmp . map swap . Map.toList $ newConsts return $ toIncSMTLib cfg progInfo inps ks (allConsts, cnsts) tbls uis as constraints cfg + mapM_ (send True) $ mergeSExpr ls -- | Retrieve the query context @@ -227,7 +238,9 @@ -- | Generalization of 'Data.SBV.Control.queryDebug' queryDebug :: (MonadIO m, MonadQuery m) => [String] -> m () queryDebug msgs = do QueryState{queryConfig} <- getQueryState - io $ debug queryConfig msgs + io $ do debug queryConfig msgs + -- If we're doing a transcript, record it there too + recordTranscript (transcript queryConfig) (DebugMsg (unlines msgs)) -- | We need to track sent asserts/check-sat calls so we can issue an extra check-sat call if needed trackAsserts :: (MonadIO m, MonadQuery m) => String -> m () @@ -429,21 +442,6 @@ , "*** This could be a bug with SBV or the backend solver. Please report!" ] --- | Registering an uninterpreted SMT function. This is typically not necessary as uses of the UI --- function itself will register it automatically. But there are cases where doing this explicitly can --- come in handy, typically in query contexts. -registerUISMTFunction :: (MonadIO m, SolverContext m) => SMTFunction fun a r => fun -> m () -registerUISMTFunction f = do st <- contextState - (nmas, isCurried) <- smtFunName f - io $ newUninterpreted st nmas (smtFunType f) (UINone isCurried) - --- | Register a kind with the solver. Like 'registerUISMTFunction', this is typically not necessary --- since SBV will register kinds as it encounters them automatically. But there are cases --- where doing this can explicitly can come handy, typically in query contexts. -registerSMTType :: forall a m. (MonadIO m, SolverContext m, HasKind a) => Proxy a -> m () -registerSMTType _ = do st <- contextState - liftIO $ registerKind st (kindOf (Proxy @a)) - -- | Pointwise function value extraction. If we get unlucky and can't parse z3's output (happens -- when we have all booleans and z3 decides to spit out an expression), just brute force our -- way out of it. Note that we only do this if we have a pure boolean type, as otherwise we'd blow @@ -889,11 +887,11 @@ cvt (KArray _ k2) = CArray $ ArrayModel [] (cvt k2) -- Tricky case of uninterpreted - uninterp _ (Just (c:_)) = CUserSort (Just 1, c) + uninterp _ (Just (c:_)) = CUserSort (Just 0, c) uninterp _ (Just []) = error "defaultKindedValue: enumerated kind with no constructors!" -- A completely uninterpreted sort, i.e., no elements. Return the witness element for it. - uninterp s Nothing = CUserSort (Nothing, s ++ "_witness") + uninterp s Nothing = CUserSort (Nothing, witnessName s) -- | Go from an SExpr directly to a value sexprToVal :: forall a. SymVal a => SExpr -> Maybe a @@ -915,7 +913,7 @@ | EReal i <- e -> Just $ CV KReal (CAlgReal i) | True -> interpretInterval e - KUserSort{} | ECon s <- e -> Just $ CV k $ CUserSort (getUIIndex k s, trim s) + KUserSort{} | ECon s <- e -> Just $ CV k $ CUserSort (getUIIndex k s, simplifyECon s) | True -> Nothing KFloat | ENum (i, _) <- e -> Just $ mkConstCV k i @@ -951,11 +949,6 @@ stringLike xs = length xs >= 2 && "\"" `isPrefixOf` xs && "\"" `isSuffixOf` xs - -- z3 prints uninterpreted values like this: T!val!4. Turn that into T_4 - trim "" = "" - trim ('!':'v':'a':'l':'!':rest) = '_' : trim rest - trim (c:cs) = c : trim cs - -- Make sure strings are really strings interpretString xs | not (stringLike xs) @@ -1789,7 +1782,20 @@ EApp es | Just xs <- mapM fromECon es -> walk xs [] _ -> bad r Nothing --- | Generalization of 'Data.SBV.Control.timeout' +-- | Timeout a query action, typically a command call to the underlying SMT solver. +-- The duration is in microseconds (@1\/10^6@ seconds). If the duration +-- is negative, then no timeout is imposed. When specifying long timeouts, be careful not to exceed +-- @maxBound :: Int@. (On a 64 bit machine, this bound is practically infinite. But on a 32 bit +-- machine, it corresponds to about 36 minutes!) +-- +-- Semantics: The call @timeout n q@ causes the timeout value to be applied to all interactive calls that take place +-- as we execute the query @q@. That is, each call that happens during the execution of @q@ gets a separate +-- time-out value, as opposed to one timeout value that limits the whole query. This is typically the intended behavior. +-- It is advisable to apply this combinator to calls that involve a single call to the solver for +-- finer control, as opposed to an entire set of interactions. However, different use cases might call for different scenarios. +-- +-- If the solver responds within the time-out specified, then we continue as usual. However, if the backend solver times-out +-- using this mechanism, there is no telling what the state of the solver will be. Thus, we raise an error in this case. timeout :: (MonadIO m, MonadQuery m) => Int -> m a -> m a timeout n q = do modifyQueryState (\qs -> qs {queryTimeOutValue = Just n}) r <- q diff --git a/Data/SBV/Core/AlgReals.hs b/Data/SBV/Core/AlgReals.hs --- a/Data/SBV/Core/AlgReals.hs +++ b/Data/SBV/Core/AlgReals.hs @@ -9,7 +9,9 @@ -- Algebraic reals in Haskell. ----------------------------------------------------------------------------- +{-# LANGUAGE DeriveAnyClass #-} {-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} {-# LANGUAGE FlexibleInstances #-} {-# OPTIONS_GHC -Wall -Werror -fno-warn-orphans #-} @@ -30,6 +32,7 @@ ) where +import Control.DeepSeq (NFData) import Data.Char (isDigit) import Data.List (sortBy, isPrefixOf, partition) @@ -43,11 +46,12 @@ import Text.Read(readMaybe) import qualified Data.Generics as G +import GHC.Generics -- | Is the endpoint included in the interval? data RealPoint a = OpenPoint a -- ^ open: i.e., doesn't include the point | ClosedPoint a -- ^ closed: i.e., includes the point - deriving (Show, Eq, Ord, G.Data) + deriving (Show, Eq, Ord, G.Data, NFData, Generic) -- | Extract the point associated with the open-closed point realPoint :: RealPoint a -> a @@ -60,7 +64,7 @@ data AlgReal = AlgRational Bool Rational -- ^ bool says it's exact (i.e., SMT-solver did not return it with ? at the end.) | AlgPolyRoot (Integer, AlgRealPoly) (Maybe String) -- ^ which root of this polynomial and an approximate decimal representation with given precision, if available | AlgInterval (RealPoint Rational) (RealPoint Rational) -- ^ interval, with low and high bounds - deriving G.Data + deriving (G.Data, Generic, NFData) -- | Check whether a given argument is an exact rational isExactRational :: AlgReal -> Bool @@ -71,7 +75,7 @@ -- coefficient list. For instance, "5x^3 + 2x - 5" is -- represented as [(5, 3), (2, 1), (-5, 0)] newtype AlgRealPoly = AlgRealPoly [(Integer, Integer)] - deriving (Eq, Ord, G.Data) + deriving (Eq, Ord, G.Data, NFData, Generic) -- | Construct a poly-root real with a given approximate value (either as a decimal, or polynomial-root) mkPolyReal :: Either (Bool, String) (Integer, [(Integer, Integer)]) -> AlgReal @@ -102,9 +106,9 @@ instance Show AlgRealPoly where show (AlgRealPoly xs) = chkEmpty (join (concat [term p | p@(_, x) <- xs, x /= 0])) ++ " = " ++ show c - where c = -1 * case [k | (k, 0) <- xs] of - h:_ -> h - _ -> 0 + where c = case [k | (k, 0) <- xs] of + h:_ -> -h + _ -> 0 term ( 0, _) = [] term ( 1, 1) = [ "x"] 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 @@ -9,6 +9,8 @@ -- Operations on concrete values ----------------------------------------------------------------------------- +{-# LANGUAGE DeriveAnyClass #-} +{-# LANGUAGE DeriveGeneric #-} {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TypeApplications #-} @@ -20,6 +22,8 @@ import Control.Monad (replicateM) +import Control.DeepSeq (NFData) + import Data.Bits import System.Random (randomIO, randomRIO) @@ -39,10 +43,12 @@ import qualified Data.Generics as G +import GHC.Generics + -- | A 'RCSet' is either a regular set or a set given by its complement from the corresponding universal set. data RCSet a = RegularSet (Set a) | ComplementSet (Set a) - deriving G.Data + deriving (NFData, G.Data, Generic) -- | Show instance. Regular sets are shown as usual. -- Complements are shown "U -" notation. @@ -78,7 +84,7 @@ -- That is, we store the history of the writes. The earlier a pair is in the list, the "later" it -- is done, i.e., it takes precedence over the latter entries. data ArrayModel a b = ArrayModel [(a, b)] b - deriving G.Data + deriving (G.Data, Generic, NFData) -- | The kind of an ArrayModel instance (HasKind a, HasKind b) => HasKind (ArrayModel a b) where @@ -102,7 +108,7 @@ | CMaybe !(Maybe CVal) -- ^ Maybe | CEither !(Either CVal CVal) -- ^ Disjoint union | CArray !(ArrayModel CVal CVal) -- ^ Arrays are backed by look-up tables concretely - deriving G.Data + deriving (G.Data, Generic, NFData) -- | Assign a rank to constant values, this is structural and helps with ordering cvRank :: CVal -> Int @@ -191,7 +197,7 @@ data CV = CV { _cvKind :: !Kind , cvVal :: !CVal } - deriving (Eq, Ord, G.Data) + deriving (Eq, Ord, G.Data, NFData, Generic) -- | A generalized CV allows for expressions involving infinite and epsilon values/intervals Used in optimization problems. data GeneralizedCV = ExtendedCV ExtCV @@ -457,7 +463,7 @@ mkConstCV k@KEither{} a = error $ "Unexpected call to mkConstCV (" ++ show k ++ ") with value: " ++ show (toInteger a) mkConstCV k@KArray{} a = error $ "Unexpected call to mkConstCV (" ++ show k ++ ") with value: " ++ show (toInteger a) --- | Generate a random constant value ('CVal') of the correct kind. +-- | Generate a random constant value ('CVal') of the correct kind. We error out for a completely uninterpreted type. randomCVal :: Kind -> IO CVal randomCVal k = case k of @@ -480,7 +486,10 @@ KString -> do l <- randomRIO (0, 100) CString <$> replicateM l (chr <$> randomRIO (0, 255)) KChar -> CChar . chr <$> randomRIO (0, 255) - KUserSort s _ -> error $ "Unexpected call to randomCVal with user kind: " ++ s + KUserSort s es -> case es of + Just vs@(_:_) -> do i <- randomRIO (0, length vs - 1) + pure $ CUserSort (Just i, vs !! i) + _ -> error $ "randomCVal: Not supported for completely uninterpreted type: " ++ s KList ek -> do l <- randomRIO (0, 100) CList <$> replicateM l (randomCVal ek) KSet ek -> do i <- randomIO -- regular or complement 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 @@ -53,17 +53,18 @@ , Op(..), PBOp(..), FPOp(..), StrOp(..), RegExOp(..), SeqOp(..), RegExp(..), NamedSymVar(..), OvOp(..), getTableIndex , SBVPgm(..), Symbolic, runSymbolic, State, getPathCondition, extendPathCondition , inSMTMode, SBVRunMode(..), Kind(..), Outputtable(..), Result(..) - , SolverContext(..), internalVariable, internalConstraint, isCodeGenMode + , SolverContext(..), internalConstraint, isCodeGenMode , SBVType(..), newUninterpreted , Quantifier(..), needsExistentials - , SMTLibPgm(..), SMTLibVersion(..), smtLibVersionExtension, smtLibReservedNames + , SMTLibPgm(..), SMTLibVersion(..), smtLibVersionExtension , SolverCapabilities(..) , extractSymbolicSimulationState - , SMTScript(..), Solver(..), SMTSolver(..), SMTResult(..), SMTModel(..), SMTConfig(..) + , SMTScript(..), Solver(..), SMTSolver(..), SMTResult(..), SMTModel(..), SMTConfig(..), KDOptions(..) , OptimizeStyle(..), Penalty(..), Objective(..) , QueryState(..), QueryT(..), SMTProblem(..), Constraint(..), Lambda(..), Forall(..), Exists(..), ExistsUnique(..), ForallN(..), ExistsN(..) , QuantifiedBool(..), EqSymbolic(..), QNot(..), Skolemize(SkolemsTo, skolemize, taggedSkolemize) , bvExtract, (#), bvDrop, bvTake + , registerType ) where import GHC.TypeLits (KnownNat, Nat, Symbol, KnownSymbol, symbolVal, AppendSymbol, type (+), type (-), type (<=), natVal) @@ -98,8 +99,6 @@ import Data.SBV.Control.Types -import Data.SBV.SMT.SMTLibNames - import Data.SBV.Utils.Lib -- | Get the current path condition @@ -550,13 +549,23 @@ -- | Get the state associated with this context contextState :: m State - {-# MINIMAL constrain, softConstrain, namedConstraint, constrainWithAttribute, setOption, contextState #-} + -- | Get an internal-variable + internalVariable :: Kind -> m (SBV a) + {-# MINIMAL constrain, softConstrain, namedConstraint, constrainWithAttribute, setOption, contextState, internalVariable #-} + -- time-out, logic, and info are simply options in our implementation, so default implementation suffices - setTimeOut t = setOption $ OptionKeyword ":timeout" [show t] + setTimeOut = setOption . SetTimeOut setLogic = setOption . SetLogic setInfo k = setOption . SetInfo k +-- | Register a type with the solver. Like 'Data.SBV.Core.Model.registerFunction', This is typically not necessary +-- since SBV will register types as it encounters them automatically. But there are cases +-- where doing this can explicitly can come handy, typically in query contexts. +registerType :: forall a m. (MonadIO m, SolverContext m, HasKind a) => Proxy a -> m () +registerType _ = do st <- contextState + liftIO $ registerKind st (kindOf (Proxy @a)) + -- | A class representing what can be returned from a symbolic computation. class Outputtable a where -- | Generalization of 'Data.SBV.output' @@ -922,7 +931,7 @@ instance (HasKind a, KnownSymbol nm, Skolemize r) => Skolemize (Exists nm a -> r) where type SkolemsTo (Exists nm a -> r) = SkolemsTo r skolem scope args f = skolem scope args (f (Exists skolemized)) - where skolemized = SBV $ svUninterpretedNamedArgs (kindOf (Proxy @a)) (scope ++ symbolVal (Proxy @nm)) (UINone True) args + where skolemized = SBV $ svUninterpretedNamedArgs (kindOf (Proxy @a)) (UIGiven (scope ++ symbolVal (Proxy @nm))) (UINone True) args -- | Skolemize over a number of existential quantifiers instance (HasKind a, KnownNat n, KnownSymbol nm, Skolemize r) => Skolemize (ExistsN n nm a -> r) where @@ -931,7 +940,7 @@ where need = intOfProxy (Proxy @n) prefix = symbolVal (Proxy @nm) fs = [prefix ++ "_" ++ show i | i <- [1 .. need]] - skolemized = [SBV $ svUninterpretedNamedArgs (kindOf (Proxy @a)) (scope ++ n) (UINone True) args | n <- fs] + skolemized = [SBV $ svUninterpretedNamedArgs (kindOf (Proxy @a)) (UIGiven (scope ++ n)) (UINone True) args | n <- fs] -- | Skolemize over a unique existential quantifier instance ( HasKind a @@ -944,7 +953,7 @@ -> Forall (AppendSymbol nm "_eu2") a -> SBool skolem scope args f = skolem scope args (rewriteExistsUnique f (Exists skolemized)) - where skolemized = SBV $ svUninterpretedNamedArgs (kindOf (Proxy @a)) (scope ++ symbolVal (Proxy @nm)) (UINone True) args + where skolemized = SBV $ svUninterpretedNamedArgs (kindOf (Proxy @a)) (UIGiven (scope ++ symbolVal (Proxy @nm))) (UINone True) args -- | Class of things that we can logically negate class QNot a where 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 @@ -12,7 +12,9 @@ {-# LANGUAGE CPP #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE DefaultSignatures #-} +{-# LANGUAGE DeriveAnyClass #-} {-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE LambdaCase #-} {-# LANGUAGE ScopedTypeVariables #-} @@ -28,13 +30,12 @@ Kind(..), HasKind(..), constructUKind, smtType, hasUninterpretedSorts , BVIsNonZero, ValidFloat, intOfProxy , showBaseKind, needsFlattening, RoundingMode(..), smtRoundingMode - , eqCheckIsObjectEq + , eqCheckIsObjectEq, expandKinds ) where import qualified Data.Generics as G (Data(..), DataType, dataTypeName, dataTypeOf, tyconUQname, dataTypeConstrs, constrFields) import Data.Char (isSpace) - import Data.Int import Data.Word import Data.SBV.Core.AlgReals @@ -42,8 +43,11 @@ import Data.Proxy import Data.Kind -import Data.List (isPrefixOf, intercalate, nub, sort) +import Data.List (isPrefixOf, intercalate, sort) +import Control.DeepSeq (NFData) +import Data.Containers.ListUtils (nubOrd) + import Data.Typeable (Typeable) import Data.Type.Bool import Data.Type.Equality @@ -52,6 +56,7 @@ import Data.SBV.Utils.Lib (isKString) +import GHC.Generics import qualified Data.Generics.Uniplate.Data as G -- | Kind of symbolic value @@ -72,11 +77,11 @@ | KRational | KEither Kind Kind | KArray Kind Kind - deriving (Eq, Ord, G.Data) + deriving (Eq, Ord, G.Data, NFData, Generic) -- Expand such that the resulting list has all the kinds we touch expandKinds :: Kind -> [Kind] -expandKinds = nub . sort . G.universe +expandKinds = sort . nubOrd . G.universe -- | The interesting about the show instance is that it can tell apart two kinds nicely; since it conveniently -- ignores the enumeration constructors. Also, when we construct a 'KUserSort', we make sure we don't use any of 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 @@ -10,7 +10,6 @@ ----------------------------------------------------------------------------- {-# LANGUAGE BangPatterns #-} -{-# LANGUAGE ConstrainedClassMethods #-} {-# LANGUAGE CPP #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE DefaultSignatures #-} @@ -18,6 +17,8 @@ {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE InstanceSigs #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE NamedFieldPuns #-} {-# LANGUAGE Rank2Types #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TypeApplications #-} @@ -28,8 +29,10 @@ {-# OPTIONS_GHC -Wall -Werror -fno-warn-orphans -Wno-incomplete-uni-patterns #-} module Data.SBV.Core.Model ( - Mergeable(..), Equality(..), EqSymbolic(..), OrdSymbolic(..), SDivisible(..), SMTDefinable(..), Metric(..), minimize, maximize, assertWithPenalty, SIntegral, SFiniteBits(..) + Mergeable(..), Equality(..), EqSymbolic(..), OrdSymbolic(..), SDivisible(..), SMTDefinable(..), QSaturate, qSaturateSavingObservables + , Metric(..), minimize, maximize, assertWithPenalty, SIntegral, SFiniteBits(..) , ite, iteLazy, sFromIntegral, sShiftLeft, sShiftRight, sRotateLeft, sBarrelRotateLeft, sRotateRight, sBarrelRotateRight, sSignedShiftArithRight, (.^) + , some , oneIf, genVar, genVar_ , pbAtMost, pbAtLeast, pbExactly, pbLe, pbGe, pbEq, pbMutexed, pbStronglyMutexed , sBool, sBool_, sBools, sWord8, sWord8_, sWord8s, sWord16, sWord16_, sWord16s, sWord32, sWord32_, sWord32s @@ -58,8 +61,8 @@ where import Control.Applicative (ZipList(ZipList)) -import Control.Monad (when, unless, mplus) -import Control.Monad.IO.Class (MonadIO) +import Control.Monad (when, unless, mplus, replicateM) +import Control.Monad.IO.Class (MonadIO, liftIO) import GHC.Generics (M1(..), U1(..), (:*:)(..), K1(..)) import qualified GHC.Generics as G @@ -109,10 +112,10 @@ import Data.SBV.Provers.Prover (defaultSMTCfg, SafeResult(..), defs2smt, prove) import Data.SBV.SMT.SMT (ThmResult, showModel) -import Data.SBV.Utils.Lib (isKString, checkObservableName) import Data.SBV.Utils.Numeric (fpIsEqualObjectH) -import Data.IORef (readIORef) +import Data.IORef (readIORef, writeIORef) +import Data.SBV.Utils.Lib -- Symbolic-Word class instances @@ -2372,6 +2375,24 @@ minBound = literal minBound maxBound = literal maxBound +-- | Choose a value that satisfies the given predicate. This is Hillbert's choice, essentially. Note that +-- if the predicate given is not satisfiable (for instance @const sFalse@), then the element returned will be arbitrary. +-- The only guarantee is that if there's at least one element that satisfies the predicate, then the returned +-- element will be one of those that do. The returned element is not guaranteed to be unique, least, greatest etc, unless +-- there happens to be exactly one satisfying element. +some :: forall a. (SymVal a, HasKind a) => String -> (SBV a -> SBool) -> SBV a +some nm cond = mk f + where mk = SBV . SVal k . Right . cache + + k = kindOf (Proxy @a) + + f st = do nm' <- newUninterpreted st (UIGiven nm) Nothing (SBVType [k]) (UINone False) + chosen <- newExpr st k $ SBVApp (Uninterpreted nm') [] + let ifExists = quantifiedBool $ \(Exists ex) -> cond ex + internalConstraint st False [] (unSBV (ifExists .=> cond (mk (pure (pure chosen))))) + pure chosen + + -- | SMT definable constants and functions, which can also be uninterpeted. -- This class captures functions that we can generate standalone-code for -- in the SMT solver. Note that we also allow uninterpreted constants and @@ -2423,6 +2444,13 @@ -- 'smtFunction' return a monadic result, please get in touch! smtFunction :: Lambda Symbolic a => String -> a -> a + -- | Register a function. This function is typically not needed as SBV will register functions used + -- automatically upon first use. However, there are scenarios (in particular query contexts) + -- where the definition isn't used before query-mode starts, and SBV (for historical reasons) + -- requires functions to be known before query-mode starts executing. In such cases, use this function + -- to register them with the system. + registerFunction :: a -> Symbolic () + -- | Uninterpret a value, i.e., add this value as a completely undefined value/function that -- the solver is free to instantiate to satisfy other constraints. -- @@ -2466,7 +2494,7 @@ -- | Most generalized form of uninterpretation, this function should not be needed -- by end-user-code, but is rather useful for the library development. - sbvDefineValue :: String -> Maybe [String] -> UIKind a -> a + sbvDefineValue :: UIName -> Maybe [String] -> UIKind a -> a -- | A synonym for 'uninterpret'. Allows us to create variables without -- having to call 'free' explicitly, i.e., without being in the symbolic monad. @@ -2478,12 +2506,20 @@ {-# MINIMAL sbvDefineValue, sbv2smt #-} -- defaults: - uninterpret nm = sbvDefineValue nm Nothing (UIFree True) - uninterpretWithArgs nm as = sbvDefineValue nm (Just as) (UIFree True) - smtFunction nm v = sbvDefineValue nm Nothing $ UIFun (v, \st fk -> namedLambda st nm fk v) - cgUninterpret nm code v = sbvDefineValue nm Nothing $ UICodeC (v, code) - sym = uninterpret + uninterpret nm = sbvDefineValue (UIGiven nm) Nothing $ UIFree True + uninterpretWithArgs nm as = sbvDefineValue (UIGiven nm) (Just as) $ UIFree True + smtFunction nm v = sbvDefineValue (UIGiven nm) Nothing $ UIFun (v, \st fk -> namedLambda TopLevel st nm fk v) + cgUninterpret nm code v = sbvDefineValue (UIGiven nm) Nothing $ UICodeC (v, code) + sym = uninterpret + default registerFunction :: forall b c. (a ~ (SBV b -> c), SymVal b, SMTDefinable c) => a -> Symbolic () + registerFunction f = do let k = kindOf (Proxy @b) + st <- symbolicEnv + v <- liftIO $ newInternalVariable st k + let b = SBV $ SVal k $ Right $ cache (const (pure v)) + registerFunction $ f b + + -- | Kind of uninterpretation data UIKind a = UIFree Bool -- ^ completely uninterpreted. If Bool is true, then this is curried. | UIFun (a, State -> Kind -> IO SMTDef) -- ^ has code for SMTLib, with final type of kind (note this is the result @@ -2492,14 +2528,15 @@ deriving Functor -- Get the code associated with the UI, unless we've already did this once. (To support recursive defs.) -retrieveUICode :: String -> State -> Kind -> UIKind a -> IO UICodeKind -retrieveUICode _ _ _ (UIFree c) = pure $ UINone c -retrieveUICode nm st fk (UIFun (_, f)) = do userFuncs <- readIORef (rUserFuncs st) - if nm `Set.member` userFuncs - then pure $ UINone True - else do modifyState st rUserFuncs (Set.insert nm) (pure ()) - UISMT <$> f st fk -retrieveUICode _ _ _ (UICodeC (_, c)) = pure $ UICgC c +retrieveUICode :: UIName -> State -> Kind -> UIKind a -> IO UICodeKind +retrieveUICode _ _ _ (UIFree c) = pure $ UINone c +retrieveUICode (UIPrefix nm) _ _ _ = error $ "Data.SBV.retrieveUICode: Unexpected prefix name received: " ++ nm +retrieveUICode (UIGiven nm) st fk (UIFun (_, f)) = do userFuncs <- readIORef (rUserFuncs st) + if nm `Set.member` userFuncs + then pure $ UINone True + else do modifyState st rUserFuncs (Set.insert nm) (pure ()) + UISMT <$> f st fk +retrieveUICode _ _ _ (UICodeC (_, c)) = pure $ UICgC c -- Get the constant value associated with the UI retrieveConstCode :: UIKind a -> Maybe a @@ -2508,14 +2545,16 @@ retrieveConstCode (UICodeC (v, _)) = Just v -- Plain constants -instance HasKind a => SMTDefinable (SBV a) where - sbv2smt a = do st <- mkNewState defaultSMTCfg (LambdaGen 0) - s <- lambdaStr st (kindOf a) a +instance (SymVal a, HasKind a) => SMTDefinable (SBV a) where + sbv2smt a = do st <- mkNewState defaultSMTCfg (LambdaGen (Just 0)) + s <- lambdaStr st TopLevel (kindOf a) a pure $ intercalate "\n" [ "; Automatically generated by SBV. Do not modify!" , "; Type: " ++ smtType (kindOf a) - , s + , show s ] + registerFunction x = constrain $ x .== x + sbvDefineValue nm mbArgs uiKind | Just v <- retrieveConstCode uiKind = v @@ -2525,8 +2564,8 @@ result st = do isSMT <- inSMTMode st case (isSMT, uiKind) of (True, UICodeC (v, _)) -> sbvToSV st v - _ -> do newUninterpreted st (nm, mbArgs) (SBVType [ka]) =<< retrieveUICode nm st ka uiKind - newExpr st ka $ SBVApp (Uninterpreted nm) [] + _ -> do nm' <- newUninterpreted st nm mbArgs (SBVType [ka]) =<< retrieveUICode nm st ka uiKind + newExpr st ka $ SBVApp (Uninterpreted nm') [] -- Functions of one argument instance (SymVal b, SymVal a, HasKind a) => SMTDefinable (SBV b -> SBV a) where @@ -2543,10 +2582,10 @@ result st = do isSMT <- inSMTMode st case (isSMT, uiKind) of (True, UICodeC (v, _)) -> sbvToSV st (v arg0) - _ -> do newUninterpreted st (nm, mbArgs) (SBVType [kb, ka]) =<< retrieveUICode nm st ka uiKind + _ -> do nm' <- newUninterpreted st nm mbArgs (SBVType [kb, ka]) =<< retrieveUICode nm st ka uiKind sw0 <- sbvToSV st arg0 mapM_ forceSVArg [sw0] - newExpr st ka $ SBVApp (Uninterpreted nm) [sw0] + newExpr st ka $ SBVApp (Uninterpreted nm') [sw0] -- Functions of two arguments instance (SymVal c, SymVal b, SymVal a, HasKind a) => SMTDefinable (SBV c -> SBV b -> SBV a) where @@ -2564,11 +2603,11 @@ result st = do isSMT <- inSMTMode st case (isSMT, uiKind) of (True, UICodeC (v, _)) -> sbvToSV st (v arg0 arg1) - _ -> do newUninterpreted st (nm, mbArgs) (SBVType [kc, kb, ka]) =<< retrieveUICode nm st ka uiKind + _ -> do nm' <- newUninterpreted st nm mbArgs (SBVType [kc, kb, ka]) =<< retrieveUICode nm st ka uiKind sw0 <- sbvToSV st arg0 sw1 <- sbvToSV st arg1 mapM_ forceSVArg [sw0, sw1] - newExpr st ka $ SBVApp (Uninterpreted nm) [sw0, sw1] + newExpr st ka $ SBVApp (Uninterpreted nm') [sw0, sw1] -- Functions of three arguments instance (SymVal d, SymVal c, SymVal b, SymVal a, HasKind a) => SMTDefinable (SBV d -> SBV c -> SBV b -> SBV a) where @@ -2587,12 +2626,12 @@ result st = do isSMT <- inSMTMode st case (isSMT, uiKind) of (True, UICodeC (v, _)) -> sbvToSV st (v arg0 arg1 arg2) - _ -> do newUninterpreted st (nm, mbArgs) (SBVType [kd, kc, kb, ka]) =<< retrieveUICode nm st ka uiKind + _ -> do nm' <- newUninterpreted st nm mbArgs (SBVType [kd, kc, kb, ka]) =<< retrieveUICode nm st ka uiKind sw0 <- sbvToSV st arg0 sw1 <- sbvToSV st arg1 sw2 <- sbvToSV st arg2 mapM_ forceSVArg [sw0, sw1, sw2] - newExpr st ka $ SBVApp (Uninterpreted nm) [sw0, sw1, sw2] + newExpr st ka $ SBVApp (Uninterpreted nm') [sw0, sw1, sw2] -- Functions of four arguments instance (SymVal e, SymVal d, SymVal c, SymVal b, SymVal a, HasKind a) => SMTDefinable (SBV e -> SBV d -> SBV c -> SBV b -> SBV a) where @@ -2612,13 +2651,13 @@ result st = do isSMT <- inSMTMode st case (isSMT, uiKind) of (True, UICodeC (v, _)) -> sbvToSV st (v arg0 arg1 arg2 arg3) - _ -> do newUninterpreted st (nm, mbArgs) (SBVType [ke, kd, kc, kb, ka]) =<< retrieveUICode nm st ka uiKind + _ -> do nm' <- newUninterpreted st nm mbArgs (SBVType [ke, kd, kc, kb, ka]) =<< retrieveUICode nm st ka uiKind sw0 <- sbvToSV st arg0 sw1 <- sbvToSV st arg1 sw2 <- sbvToSV st arg2 sw3 <- sbvToSV st arg3 mapM_ forceSVArg [sw0, sw1, sw2, sw3] - newExpr st ka $ SBVApp (Uninterpreted nm) [sw0, sw1, sw2, sw3] + newExpr st ka $ SBVApp (Uninterpreted nm') [sw0, sw1, sw2, sw3] -- Functions of five arguments instance (SymVal f, SymVal e, SymVal d, SymVal c, SymVal b, SymVal a, HasKind a) => SMTDefinable (SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) where @@ -2639,14 +2678,14 @@ result st = do isSMT <- inSMTMode st case (isSMT, uiKind) of (True, UICodeC (v, _)) -> sbvToSV st (v arg0 arg1 arg2 arg3 arg4) - _ -> do newUninterpreted st (nm, mbArgs) (SBVType [kf, ke, kd, kc, kb, ka]) =<< retrieveUICode nm st ka uiKind + _ -> do nm' <- newUninterpreted st nm mbArgs (SBVType [kf, ke, kd, kc, kb, ka]) =<< retrieveUICode nm st ka uiKind sw0 <- sbvToSV st arg0 sw1 <- sbvToSV st arg1 sw2 <- sbvToSV st arg2 sw3 <- sbvToSV st arg3 sw4 <- sbvToSV st arg4 mapM_ forceSVArg [sw0, sw1, sw2, sw3, sw4] - newExpr st ka $ SBVApp (Uninterpreted nm) [sw0, sw1, sw2, sw3, sw4] + newExpr st ka $ SBVApp (Uninterpreted nm') [sw0, sw1, sw2, sw3, sw4] -- Functions of six arguments instance (SymVal g, SymVal f, SymVal e, SymVal d, SymVal c, SymVal b, SymVal a, HasKind a) => SMTDefinable (SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) where @@ -2668,7 +2707,7 @@ result st = do isSMT <- inSMTMode st case (isSMT, uiKind) of (True, UICodeC (v, _)) -> sbvToSV st (v arg0 arg1 arg2 arg3 arg4 arg5) - _ -> do newUninterpreted st (nm, mbArgs) (SBVType [kg, kf, ke, kd, kc, kb, ka]) =<< retrieveUICode nm st ka uiKind + _ -> do nm' <- newUninterpreted st nm mbArgs (SBVType [kg, kf, ke, kd, kc, kb, ka]) =<< retrieveUICode nm st ka uiKind sw0 <- sbvToSV st arg0 sw1 <- sbvToSV st arg1 sw2 <- sbvToSV st arg2 @@ -2676,7 +2715,7 @@ sw4 <- sbvToSV st arg4 sw5 <- sbvToSV st arg5 mapM_ forceSVArg [sw0, sw1, sw2, sw3, sw4, sw5] - newExpr st ka $ SBVApp (Uninterpreted nm) [sw0, sw1, sw2, sw3, sw4, sw5] + newExpr st ka $ SBVApp (Uninterpreted nm') [sw0, sw1, sw2, sw3, sw4, sw5] -- Functions of seven arguments instance (SymVal h, SymVal g, SymVal f, SymVal e, SymVal d, SymVal c, SymVal b, SymVal a, HasKind a) @@ -2700,7 +2739,7 @@ result st = do isSMT <- inSMTMode st case (isSMT, uiKind) of (True, UICodeC (v, _)) -> sbvToSV st (v arg0 arg1 arg2 arg3 arg4 arg5 arg6) - _ -> do newUninterpreted st (nm, mbArgs) (SBVType [kh, kg, kf, ke, kd, kc, kb, ka]) =<< retrieveUICode nm st ka uiKind + _ -> do nm' <- newUninterpreted st nm mbArgs (SBVType [kh, kg, kf, ke, kd, kc, kb, ka]) =<< retrieveUICode nm st ka uiKind sw0 <- sbvToSV st arg0 sw1 <- sbvToSV st arg1 sw2 <- sbvToSV st arg2 @@ -2709,7 +2748,7 @@ sw5 <- sbvToSV st arg5 sw6 <- sbvToSV st arg6 mapM_ forceSVArg [sw0, sw1, sw2, sw3, sw4, sw5, sw6] - newExpr st ka $ SBVApp (Uninterpreted nm) [sw0, sw1, sw2, sw3, sw4, sw5, sw6] + newExpr st ka $ SBVApp (Uninterpreted nm') [sw0, sw1, sw2, sw3, sw4, sw5, sw6] -- Functions of eight arguments instance (SymVal i, SymVal h, SymVal g, SymVal f, SymVal e, SymVal d, SymVal c, SymVal b, SymVal a, SymVal a, HasKind a) @@ -2734,7 +2773,7 @@ result st = do isSMT <- inSMTMode st case (isSMT, uiKind) of (True, UICodeC (v, _)) -> sbvToSV st (v arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7) - _ -> do newUninterpreted st (nm, mbArgs) (SBVType [ki, kh, kg, kf, ke, kd, kc, kb, ka]) =<< retrieveUICode nm st ka uiKind + _ -> do nm' <- newUninterpreted st nm mbArgs (SBVType [ki, kh, kg, kf, ke, kd, kc, kb, ka]) =<< retrieveUICode nm st ka uiKind sw0 <- sbvToSV st arg0 sw1 <- sbvToSV st arg1 sw2 <- sbvToSV st arg2 @@ -2744,7 +2783,7 @@ sw6 <- sbvToSV st arg6 sw7 <- sbvToSV st arg7 mapM_ forceSVArg [sw0, sw1, sw2, sw3, sw4, sw5, sw6, sw7] - newExpr st ka $ SBVApp (Uninterpreted nm) [sw0, sw1, sw2, sw3, sw4, sw5, sw6, sw7] + newExpr st ka $ SBVApp (Uninterpreted nm') [sw0, sw1, sw2, sw3, sw4, sw5, sw6, sw7] -- Functions of nine arguments instance (SymVal j, SymVal i, SymVal h, SymVal g, SymVal f, SymVal e, SymVal d, SymVal c, SymVal b, SymVal a, HasKind a) @@ -2770,7 +2809,7 @@ result st = do isSMT <- inSMTMode st case (isSMT, uiKind) of (True, UICodeC (v, _)) -> sbvToSV st (v arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8) - _ -> do newUninterpreted st (nm, mbArgs) (SBVType [kj, ki, kh, kg, kf, ke, kd, kc, kb, ka]) =<< retrieveUICode nm st ka uiKind + _ -> do nm' <- newUninterpreted st nm mbArgs (SBVType [kj, ki, kh, kg, kf, ke, kd, kc, kb, ka]) =<< retrieveUICode nm st ka uiKind sw0 <- sbvToSV st arg0 sw1 <- sbvToSV st arg1 sw2 <- sbvToSV st arg2 @@ -2781,7 +2820,7 @@ sw7 <- sbvToSV st arg7 sw8 <- sbvToSV st arg8 mapM_ forceSVArg [sw0, sw1, sw2, sw3, sw4, sw5, sw6, sw7, sw8] - newExpr st ka $ SBVApp (Uninterpreted nm) [sw0, sw1, sw2, sw3, sw4, sw5, sw6, sw7, sw8] + newExpr st ka $ SBVApp (Uninterpreted nm') [sw0, sw1, sw2, sw3, sw4, sw5, sw6, sw7, sw8] -- Functions of ten arguments instance (SymVal k, SymVal j, SymVal i, SymVal h, SymVal g, SymVal f, SymVal e, SymVal d, SymVal c, SymVal b, SymVal a, HasKind a) @@ -2808,7 +2847,7 @@ result st = do isSMT <- inSMTMode st case (isSMT, uiKind) of (True, UICodeC (v, _)) -> sbvToSV st (v arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9) - _ -> do newUninterpreted st (nm, mbArgs) (SBVType [kk, kj, ki, kh, kg, kf, ke, kd, kc, kb, ka]) =<< retrieveUICode nm st ka uiKind + _ -> do nm' <- newUninterpreted st nm mbArgs (SBVType [kk, kj, ki, kh, kg, kf, ke, kd, kc, kb, ka]) =<< retrieveUICode nm st ka uiKind sw0 <- sbvToSV st arg0 sw1 <- sbvToSV st arg1 sw2 <- sbvToSV st arg2 @@ -2820,7 +2859,7 @@ sw8 <- sbvToSV st arg8 sw9 <- sbvToSV st arg9 mapM_ forceSVArg [sw0, sw1, sw2, sw3, sw4, sw5, sw6, sw7, sw8, sw9] - newExpr st ka $ SBVApp (Uninterpreted nm) [sw0, sw1, sw2, sw3, sw4, sw5, sw6, sw7, sw8, sw9] + newExpr st ka $ SBVApp (Uninterpreted nm') [sw0, sw1, sw2, sw3, sw4, sw5, sw6, sw7, sw8, sw9] -- Functions of eleven arguments instance (SymVal l, SymVal k, SymVal j, SymVal i, SymVal h, SymVal g, SymVal f, SymVal e, SymVal d, SymVal c, SymVal b, SymVal a, HasKind a) @@ -2848,7 +2887,7 @@ result st = do isSMT <- inSMTMode st case (isSMT, uiKind) of (True, UICodeC (v, _)) -> sbvToSV st (v arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10) - _ -> do newUninterpreted st (nm, mbArgs) (SBVType [kl, kk, kj, ki, kh, kg, kf, ke, kd, kc, kb, ka]) =<< retrieveUICode nm st ka uiKind + _ -> do nm' <- newUninterpreted st nm mbArgs (SBVType [kl, kk, kj, ki, kh, kg, kf, ke, kd, kc, kb, ka]) =<< retrieveUICode nm st ka uiKind sw0 <- sbvToSV st arg0 sw1 <- sbvToSV st arg1 sw2 <- sbvToSV st arg2 @@ -2861,7 +2900,7 @@ sw9 <- sbvToSV st arg9 sw10 <- sbvToSV st arg10 mapM_ forceSVArg [sw0, sw1, sw2, sw3, sw4, sw5, sw6, sw7, sw8, sw9, sw10] - newExpr st ka $ SBVApp (Uninterpreted nm) [sw0, sw1, sw2, sw3, sw4, sw5, sw6, sw7, sw8, sw9, sw10] + newExpr st ka $ SBVApp (Uninterpreted nm') [sw0, sw1, sw2, sw3, sw4, sw5, sw6, sw7, sw8, sw9, sw10] -- Functions of twelve arguments instance (SymVal m, SymVal l, SymVal k, SymVal j, SymVal i, SymVal h, SymVal g, SymVal f, SymVal e, SymVal d, SymVal c, SymVal b, SymVal a, HasKind a) @@ -2890,7 +2929,7 @@ result st = do isSMT <- inSMTMode st case (isSMT, uiKind) of (True, UICodeC (v, _)) -> sbvToSV st (v arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10 arg11) - _ -> do newUninterpreted st (nm, mbArgs) (SBVType [km, kl, kk, kj, ki, kh, kg, kf, ke, kd, kc, kb, ka]) =<< retrieveUICode nm st ka uiKind + _ -> do nm' <- newUninterpreted st nm mbArgs (SBVType [km, kl, kk, kj, ki, kh, kg, kf, ke, kd, kc, kb, ka]) =<< retrieveUICode nm st ka uiKind sw0 <- sbvToSV st arg0 sw1 <- sbvToSV st arg1 sw2 <- sbvToSV st arg2 @@ -2904,7 +2943,7 @@ sw10 <- sbvToSV st arg10 sw11 <- sbvToSV st arg11 mapM_ forceSVArg [sw0, sw1, sw2, sw3, sw4, sw5, sw6, sw7, sw8, sw9, sw10, sw11] - newExpr st ka $ SBVApp (Uninterpreted nm) [sw0, sw1, sw2, sw3, sw4, sw5, sw6, sw7, sw8, sw9, sw10, sw11] + newExpr st ka $ SBVApp (Uninterpreted nm') [sw0, sw1, sw2, sw3, sw4, sw5, sw6, sw7, sw8, sw9, sw10, sw11] -- Mark the UIKind as uncurried mkUncurried :: UIKind a -> UIKind a @@ -2914,88 +2953,69 @@ -- Uncurried functions of two arguments instance (SymVal c, SymVal b, SymVal a, HasKind a) => SMTDefinable ((SBV c, SBV b) -> SBV a) where - sbv2smt fn = defs2smt $ \p -> fn p .== fn p - - sbvDefineValue nm mbArgs uiKind = let f = sbvDefineValue nm mbArgs (curry <$> mkUncurried uiKind) in uncurry f + sbv2smt fn = defs2smt $ \p -> fn p .== fn p + registerFunction = registerFunction . curry2 + sbvDefineValue nm mbArgs uiKind = let f = sbvDefineValue nm mbArgs (curry2 <$> mkUncurried uiKind) in uncurry2 f -- Uncurried functions of three arguments instance (SymVal d, SymVal c, SymVal b, SymVal a, HasKind a) => SMTDefinable ((SBV d, SBV c, SBV b) -> SBV a) where - sbv2smt fn = defs2smt $ \p -> fn p .== fn p - - sbvDefineValue nm mbArgs uiKind = let f = sbvDefineValue nm mbArgs (uc3 <$> mkUncurried uiKind) in \(arg0, arg1, arg2) -> f arg0 arg1 arg2 - where uc3 fn a b c = fn (a, b, c) + sbv2smt fn = defs2smt $ \p -> fn p .== fn p + registerFunction = registerFunction . curry3 + sbvDefineValue nm mbArgs uiKind = let f = sbvDefineValue nm mbArgs (curry3 <$> mkUncurried uiKind) in uncurry3 f -- Uncurried functions of four arguments -instance (SymVal e, SymVal d, SymVal c, SymVal b, SymVal a, HasKind a) - => SMTDefinable ((SBV e, SBV d, SBV c, SBV b) -> SBV a) where - sbv2smt fn = defs2smt $ \p -> fn p .== fn p - - sbvDefineValue nm mbArgs uiKind = let f = sbvDefineValue nm mbArgs (uc4 <$> mkUncurried uiKind) in \(arg0, arg1, arg2, arg3) -> f arg0 arg1 arg2 arg3 - where uc4 fn a b c d = fn (a, b, c, d) +instance (SymVal e, SymVal d, SymVal c, SymVal b, SymVal a, HasKind a) => SMTDefinable ((SBV e, SBV d, SBV c, SBV b) -> SBV a) where + sbv2smt fn = defs2smt $ \p -> fn p .== fn p + registerFunction = registerFunction . curry4 + sbvDefineValue nm mbArgs uiKind = let f = sbvDefineValue nm mbArgs (curry4 <$> mkUncurried uiKind) in uncurry4 f -- Uncurried functions of five arguments -instance (SymVal f, SymVal e, SymVal d, SymVal c, SymVal b, SymVal a, HasKind a) - => SMTDefinable ((SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) where - sbv2smt fn = defs2smt $ \p -> fn p .== fn p - - sbvDefineValue nm mbArgs uiKind = let f = sbvDefineValue nm mbArgs (uc5 <$> mkUncurried uiKind) in \(arg0, arg1, arg2, arg3, arg4) -> f arg0 arg1 arg2 arg3 arg4 - where uc5 fn a b c d e = fn (a, b, c, d, e) +instance (SymVal f, SymVal e, SymVal d, SymVal c, SymVal b, SymVal a, HasKind a) => SMTDefinable ((SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) where + sbv2smt fn = defs2smt $ \p -> fn p .== fn p + registerFunction = registerFunction . curry5 + sbvDefineValue nm mbArgs uiKind = let f = sbvDefineValue nm mbArgs (curry5 <$> mkUncurried uiKind) in uncurry5 f -- Uncurried functions of six arguments -instance (SymVal g, SymVal f, SymVal e, SymVal d, SymVal c, SymVal b, SymVal a, HasKind a) - => SMTDefinable ((SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) where - sbv2smt fn = defs2smt $ \p -> fn p .== fn p - - sbvDefineValue nm mbArgs uiKind = let f = sbvDefineValue nm mbArgs (uc6 <$> mkUncurried uiKind) in \(arg0, arg1, arg2, arg3, arg4, arg5) -> f arg0 arg1 arg2 arg3 arg4 arg5 - where uc6 fn a b c d e f = fn (a, b, c, d, e, f) +instance (SymVal g, SymVal f, SymVal e, SymVal d, SymVal c, SymVal b, SymVal a, HasKind a) => SMTDefinable ((SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) where + sbv2smt fn = defs2smt $ \p -> fn p .== fn p + registerFunction = registerFunction . curry6 + sbvDefineValue nm mbArgs uiKind = let f = sbvDefineValue nm mbArgs (curry6 <$> mkUncurried uiKind) in uncurry6 f -- Uncurried functions of seven arguments -instance (SymVal h, SymVal g, SymVal f, SymVal e, SymVal d, SymVal c, SymVal b, SymVal a, HasKind a) - => SMTDefinable ((SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) where - sbv2smt fn = defs2smt $ \p -> fn p .== fn p - - sbvDefineValue nm mbArgs uiKind = let f = sbvDefineValue nm mbArgs (uc7 <$> mkUncurried uiKind) in \(arg0, arg1, arg2, arg3, arg4, arg5, arg6) -> f arg0 arg1 arg2 arg3 arg4 arg5 arg6 - where uc7 fn a b c d e f g = fn (a, b, c, d, e, f, g) +instance (SymVal h, SymVal g, SymVal f, SymVal e, SymVal d, SymVal c, SymVal b, SymVal a, HasKind a) => SMTDefinable ((SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) where + sbv2smt fn = defs2smt $ \p -> fn p .== fn p + registerFunction = registerFunction . curry7 + sbvDefineValue nm mbArgs uiKind = let f = sbvDefineValue nm mbArgs (curry7 <$> mkUncurried uiKind) in uncurry7 f -- Uncurried functions of eight arguments -instance (SymVal i, SymVal h, SymVal g, SymVal f, SymVal e, SymVal d, SymVal c, SymVal b, SymVal a, HasKind a) - => SMTDefinable ((SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) where - sbv2smt fn = defs2smt $ \p -> fn p .== fn p - - sbvDefineValue nm mbArgs uiKind = let f = sbvDefineValue nm mbArgs (uc8 <$> mkUncurried uiKind) in \(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) -> f arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 - where uc8 fn a b c d e f g h = fn (a, b, c, d, e, f, g, h) +instance (SymVal i, SymVal h, SymVal g, SymVal f, SymVal e, SymVal d, SymVal c, SymVal b, SymVal a, HasKind a) => SMTDefinable ((SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) where + sbv2smt fn = defs2smt $ \p -> fn p .== fn p + registerFunction = registerFunction . curry8 + sbvDefineValue nm mbArgs uiKind = let f = sbvDefineValue nm mbArgs (curry8 <$> mkUncurried uiKind) in uncurry8 f -- Uncurried functions of nine arguments -instance (SymVal j, SymVal i, SymVal h, SymVal g, SymVal f, SymVal e, SymVal d, SymVal c, SymVal b, SymVal a, HasKind a) - => SMTDefinable ((SBV j, SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) where - sbv2smt fn = defs2smt $ \p -> fn p .== fn p - - sbvDefineValue nm mbArgs uiKind = let f = sbvDefineValue nm mbArgs (uc9 <$> mkUncurried uiKind) in \(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) -> f arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 - where uc9 fn a b c d e f g h i = fn (a, b, c, d, e, f, g, h, i) +instance (SymVal j, SymVal i, SymVal h, SymVal g, SymVal f, SymVal e, SymVal d, SymVal c, SymVal b, SymVal a, HasKind a) => SMTDefinable ((SBV j, SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) where + sbv2smt fn = defs2smt $ \p -> fn p .== fn p + registerFunction = registerFunction . curry9 + sbvDefineValue nm mbArgs uiKind = let f = sbvDefineValue nm mbArgs (curry9 <$> mkUncurried uiKind) in uncurry9 f -- Uncurried functions of ten arguments -instance (SymVal k, SymVal j, SymVal i, SymVal h, SymVal g, SymVal f, SymVal e, SymVal d, SymVal c, SymVal b, SymVal a, HasKind a) - => SMTDefinable ((SBV k, SBV j, SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) where - sbv2smt fn = defs2smt $ \p -> fn p .== fn p - - sbvDefineValue nm mbArgs uiKind = let f = sbvDefineValue nm mbArgs (uc10 <$> mkUncurried uiKind) in \(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) -> f arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 - where uc10 fn a b c d e f g h i j = fn (a, b, c, d, e, f, g, h, i, j) +instance (SymVal k, SymVal j, SymVal i, SymVal h, SymVal g, SymVal f, SymVal e, SymVal d, SymVal c, SymVal b, SymVal a, HasKind a) => SMTDefinable ((SBV k, SBV j, SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) where + sbv2smt fn = defs2smt $ \p -> fn p .== fn p + registerFunction = registerFunction . curry10 + sbvDefineValue nm mbArgs uiKind = let f = sbvDefineValue nm mbArgs (curry10 <$> mkUncurried uiKind) in uncurry10 f -- Uncurried functions of eleven arguments -instance (SymVal l, SymVal k, SymVal j, SymVal i, SymVal h, SymVal g, SymVal f, SymVal e, SymVal d, SymVal c, SymVal b, SymVal a, HasKind a) - => SMTDefinable ((SBV l, SBV k, SBV j, SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) where - sbv2smt fn = defs2smt $ \p -> fn p .== fn p - - sbvDefineValue nm mbArgs uiKind = let f = sbvDefineValue nm mbArgs (uc11 <$> mkUncurried uiKind) in \(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10) -> f arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10 - where uc11 fn a b c d e f g h i j k = fn (a, b, c, d, e, f, g, h, i, j, k) +instance (SymVal l, SymVal k, SymVal j, SymVal i, SymVal h, SymVal g, SymVal f, SymVal e, SymVal d, SymVal c, SymVal b, SymVal a, HasKind a) => SMTDefinable ((SBV l, SBV k, SBV j, SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) where + sbv2smt fn = defs2smt $ \p -> fn p .== fn p + registerFunction = registerFunction . curry11 + sbvDefineValue nm mbArgs uiKind = let f = sbvDefineValue nm mbArgs (curry11 <$> mkUncurried uiKind) in uncurry11 f -- Uncurried functions of twelve arguments -instance (SymVal m, SymVal l, SymVal k, SymVal j, SymVal i, SymVal h, SymVal g, SymVal f, SymVal e, SymVal d, SymVal c, SymVal b, SymVal a, HasKind a) - => SMTDefinable ((SBV m, SBV l, SBV k, SBV j, SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) where - sbv2smt fn = defs2smt $ \p -> fn p .== fn p - - sbvDefineValue nm mbArgs uiKind = let f = sbvDefineValue nm mbArgs (uc12 <$> mkUncurried uiKind) in \(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11) -> f arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10 arg11 - where uc12 fn a b c d e f g h i j k l = fn (a, b, c, d, e, f, g, h, i, j, k, l) +instance (SymVal m, SymVal l, SymVal k, SymVal j, SymVal i, SymVal h, SymVal g, SymVal f, SymVal e, SymVal d, SymVal c, SymVal b, SymVal a, HasKind a) => SMTDefinable ((SBV m, SBV l, SBV k, SBV j, SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) where + sbv2smt fn = defs2smt $ \p -> fn p .== fn p + registerFunction = registerFunction . curry12 + sbvDefineValue nm mbArgs uiKind = let f = sbvDefineValue nm mbArgs (curry12 <$> mkUncurried uiKind) in uncurry12 f -- | Symbolic computations provide a context for writing symbolic programs. instance MonadIO m => SolverContext (SymbolicT m) where @@ -3007,6 +3027,10 @@ contextState = symbolicEnv setOption o = addNewSMTOption o + internalVariable k = contextState >>= \st -> liftIO $ do + sv <- newInternalVariable st k + pure $ SBV $ SVal k (Right (cache (const (pure sv)))) + -- | Generalization of 'Data.SBV.assertWithPenalty' assertWithPenalty :: MonadSymbolic m => String -> SBool -> Penalty -> m () assertWithPenalty nm o p = addSValOptGoal $ unSBV `fmap` AssertWithPenalty nm o p @@ -3192,6 +3216,41 @@ res = f xsbv sbvToSV st res +-- | Class of things that we can logically reduce to a boolean, by saturating and then asserting equivalance to itself +class QSaturate m a where + qSaturate :: a -> m () + +-- | Base case; simple variable in the symbolic monad +instance SolverContext m => QSaturate m SBool where + qSaturate b = constrain $ b .== b + +-- | Saturate over a universal quantifier +instance (HasKind a, Monad m, SolverContext m, QSaturate m r) => QSaturate m (Forall nm a -> r) where + qSaturate f = qSaturate . f . Forall =<< internalVariable (kindOf (Proxy @a)) + +-- | Saturate over an a number of universal quantifiers +instance (KnownNat n, HasKind a, Monad m, SolverContext m, QSaturate m r) => QSaturate m (ForallN n nm a -> r) where + qSaturate f = qSaturate . f . ForallN =<< replicateM (intOfProxy (Proxy @n)) (internalVariable (kindOf (Proxy @a))) + +-- | Saturate over an existential quantifier +instance (HasKind a, Monad m, SolverContext m, QSaturate m r) => QSaturate m (Exists nm a -> r) where + qSaturate f = qSaturate . f . Exists =<< internalVariable (kindOf (Proxy @a)) + +-- | Saturate over an a number of existential quantifiers +instance (KnownNat n, HasKind a, Monad m, SolverContext m, QSaturate m r) => QSaturate m (ExistsN n nm a -> r) where + qSaturate f = qSaturate . f . ExistsN =<< replicateM (intOfProxy (Proxy @n)) (internalVariable (kindOf (Proxy @a))) + +-- | Saturate over a unique-exists variable +instance (HasKind a, Monad m, SolverContext m, QSaturate m r) => QSaturate m (ExistsUnique nm a -> r) where + qSaturate f = qSaturate . f . ExistsUnique =<< internalVariable (kindOf (Proxy @a)) + +-- | Saturate a predicate, but save/restore observables so they're not messed up. +qSaturateSavingObservables :: (Monad m, MonadIO m, SolverContext m, QSaturate m a) => a -> m () +qSaturateSavingObservables p = do State{rObservables} <- contextState + curObservables <- liftIO $ readIORef rObservables + qSaturate p + liftIO $ writeIORef rObservables curObservables + -- | Equality as a proof method. Allows for -- very concise construction of equivalence proofs, which is very typical in -- bit-precise proofs. @@ -3273,12 +3332,13 @@ lambdaArray f = SBV . SVal k . Right $ cache g where k = KArray (kindOf (Proxy @a)) (kindOf (Proxy @b)) - g st = do def <- lambdaStr st (kindOf (Proxy @b)) f + g st = do def <- lambdaStr st TopLevel (kindOf (Proxy @b)) f newExpr st k (SBVApp (ArrayLambda def) []) -- | Turn a constant association-list and a default into a symbolic array. listArray :: (SymVal a, SymVal b) => [(a, b)] -> b -> SArray a b listArray ascs def = literal $ ArrayModel ascs def -{- HLint ignore module "Reduce duplication" -} -{- HLint ignore module "Eta reduce" -} +{- HLint ignore module "Reduce duplication" -} +{- HLint ignore module "Eta reduce" -} +{- HLint ignore module "Avoid NonEmpty.unzip" -} 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 @@ -1526,7 +1526,7 @@ if cg then do f <- svToSV st fVal newExpr st w32 (SBVApp (IEEEFP (FP_Reinterpret KFloat w32)) [f]) - else do n <- internalVariable st w32 + else do n <- newInternalVariable st w32 ysw <- newExpr st KFloat (SBVApp (IEEEFP (FP_Reinterpret w32 KFloat)) [n]) internalConstraint st False [] $ fVal `svStrongEqual` SVal KFloat (Right (cache (\_ -> return ysw))) return n @@ -1552,7 +1552,7 @@ if cg then do f <- svToSV st fVal newExpr st w64 (SBVApp (IEEEFP (FP_Reinterpret KDouble w64)) [f]) - else do n <- internalVariable st w64 + else do n <- newInternalVariable st w64 ysw <- newExpr st KDouble (SBVApp (IEEEFP (FP_Reinterpret w64 KDouble)) [n]) internalConstraint st False [] $ fVal `svStrongEqual` SVal KDouble (Right (cache (\_ -> return ysw))) return n @@ -1571,7 +1571,7 @@ if cg then do f <- svToSV st fVal newExpr st kTo (SBVApp (IEEEFP (FP_Reinterpret kFrom kTo)) [f]) - else do n <- internalVariable st kTo + else do n <- newInternalVariable st kTo ysw <- newExpr st kFrom (SBVApp (IEEEFP (FP_Reinterpret kTo kFrom)) [n]) internalConstraint st False [] $ fVal `svStrongEqual` SVal kFrom (Right (cache (\_ -> return ysw))) return n 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 @@ -50,6 +50,8 @@ import qualified Data.Generics as G +import Control.DeepSeq(NFData(..)) + -- | A floating point value, indexed by its exponent and significand sizes. -- -- An IEEE SP is @FloatingPoint 8 24@ @@ -100,6 +102,10 @@ , fpValue :: BigFloat } deriving (Eq, G.Data) + +-- Not full, but good enough +instance NFData FP where + rnf (FP e s _) = e `seq` s `seq` () -- Manually implemented instance as GHC generated a non-IEEE 754 compliant instance. -- Note that we cannot pack the values in a tuple and then compare them as that will 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 @@ -38,7 +38,7 @@ ( NodeId(..) , SV(..), swKind, trueSV, falseSV, contextOfSV , Op(..), PBOp(..), OvOp(..), FPOp(..), NROp(..), StrOp(..), RegExOp(..), SeqOp(..), SetOp(..), SpecialRelOp(..) - , RegExp(..), regExpToSMTString + , RegExp(..), regExpToSMTString, SMTLambda(..) , Quantifier(..), needsExistentials, SBVContext(..), checkCompatibleContext, VarContext(..) , RoundingMode(..) , SBVType(..), svUninterpreted, svUninterpretedNamedArgs, newUninterpreted @@ -53,20 +53,20 @@ , lookupInput , getSValPathCondition, extendSValPathCondition , getTableIndex, sObserve , SBVPgm(..), MonadSymbolic(..), SymbolicT, Symbolic, runSymbolic, mkNewState, runSymbolicInState, State(..), SMTDef(..), smtDefGivenName, withNewIncState, IncState(..), incrementInternalCounter - , inSMTMode, SBVRunMode(..), IStage(..), Result(..), ResultInp(..), UICodeKind(..) - , registerKind, registerLabel, recordObservable - , addAssertion, addNewSMTOption, imposeConstraint, internalConstraint, internalVariable, lambdaVar, quantVar + , inSMTMode, SBVRunMode(..), IStage(..), Result(..), ResultInp(..), UICodeKind(..), UIName(..) + , registerKind, registerLabel, registerSpecialFunction, recordObservable + , addAssertion, addNewSMTOption, imposeConstraint, internalConstraint, newInternalVariable, lambdaVar, quantVar , SMTLibPgm(..), SMTLibVersion(..), smtLibVersionExtension , SolverCapabilities(..) , extractSymbolicSimulationState, CnstMap , OptimizeStyle(..), Objective(..), Penalty(..), objectiveName, addSValOptGoal , MonadQuery(..), QueryT(..), Query, QueryState(..), QueryContext(..) - , SMTScript(..), Solver(..), SMTSolver(..), SMTResult(..), SMTModel(..), SMTConfig(..), SMTEngine + , SMTScript(..), Solver(..), SMTSolver(..), SMTResult(..), SMTModel(..), SMTConfig(..), KDOptions(..), SMTEngine, isEmptyModel , validationRequested, outputSVal, ProgInfo(..), mustIgnoreVar, getRootState ) where import Control.DeepSeq (NFData(..)) -import Control.Monad (when) +import Control.Monad (when, unless) import Control.Monad.Except (MonadError, ExceptT) import Control.Monad.Reader (MonadReader(..), ReaderT, runReaderT, mapReaderT) @@ -74,9 +74,9 @@ import Control.Monad.Trans (MonadIO(liftIO), MonadTrans(lift)) import Control.Monad.Trans.Maybe (MaybeT) import Control.Monad.Writer.Strict (MonadWriter) -import Data.Char (isAlpha, isAlphaNum, toLower, isSpace) +import Data.Char (isSpace) import Data.IORef (IORef, newIORef, readIORef) -import Data.List (intercalate, sortBy, isPrefixOf, isSuffixOf, nub) +import Data.List (intercalate, sortBy, isPrefixOf) import Data.Maybe (fromMaybe, mapMaybe) import Data.String (IsString(fromString)) @@ -97,7 +97,7 @@ import qualified Data.Generics as G (Data(..)) import qualified Data.Generics.Uniplate.Data as G import qualified Data.IntMap.Strict as IMap (IntMap, empty, lookup, insertWith) -import qualified Data.Map.Strict as Map (Map, empty, toList, lookup, insert, size) +import qualified Data.Map.Strict as Map (Map, empty, toList, lookup, insert, size, notMember) import qualified Data.Set as Set (Set, empty, toList, insert, member) import qualified Data.Foldable as F (toList) import qualified Data.Sequence as S (Seq, empty, (|>), (<|), lookup, elemIndexL) @@ -110,8 +110,10 @@ import Data.SBV.Core.Concrete import Data.SBV.SMT.SMTLibNames import Data.SBV.Utils.TDiff (Timing) -import Data.SBV.Utils.Lib (stringToQFS, checkObservableName) +import Data.SBV.Utils.Lib (stringToQFS, checkObservableName, needsBars) +import Data.Containers.ListUtils (nubOrd) + import Data.SBV.Control.Types #if MIN_VERSION_base(4,11,0) @@ -139,7 +141,7 @@ else pure ctx -- | A symbolic node id -newtype NodeId = NodeId { getId :: (SBVContext, Int, Int) } -- Lambda-level, and node-id +newtype NodeId = NodeId { getId :: (SBVContext, Maybe Int, Int) } -- Lambda-level, and node-id deriving (Ord, G.Data) -- Equality is pair-wise, except we accommodate for negative node-id; which is reserved for true/false @@ -175,8 +177,9 @@ -1 -> "true" _ -> prefix ++ 's' : show n where prefix = case l of - 0 -> "" - _ -> 'l' : show l ++ "_" + Nothing -> "arg" -- top-level lambda + Just 0 -> "" + Just i -> 'l' : show i ++ "_" -- | Kind of a symbolic word. swKind :: SV -> Kind @@ -194,11 +197,11 @@ -- | Constant False as an 'SV'. Note that this value always occupies slot -2 and level 0. falseSV :: SV -falseSV = SV KBool $ NodeId (globalSBVContext, 0, -2) +falseSV = SV KBool $ NodeId (globalSBVContext, Just 0, -2) -- | Constant True as an 'SV'. Note that this value always occupies slot -1 and level 0. trueSV :: SV -trueSV = SV KBool $ NodeId (globalSBVContext, 0, -1) +trueSV = SV KBool $ NodeId (globalSBVContext, Just 0, -1) -- | Symbolic operations data Op = Plus @@ -232,7 +235,7 @@ | LkUp (Int, Kind, Kind, Int) !SV !SV -- (table-index, arg-type, res-type, length of the table) index out-of-bounds-value | KindCast Kind Kind | Uninterpreted String - | QuantifiedBool [Op] String -- When we generate a forall/exists (nested etc.) boolean value + | QuantifiedBool String -- When we generate a forall/exists (nested etc.) boolean value. NB. This used to be "QuantifiedBool [Op] String", keeping track of Ops. That turned out to cause memory leaks. So avoid that. | SpecialRelOp Kind SpecialRelOp -- Generate the equality to the internal operation | Label String -- Essentially no-op; useful for code generation to emit comments. | IEEEFP FPOp -- Floating-point ops, categorized separately @@ -252,7 +255,7 @@ | 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 - | ArrayLambda String -- An array value, created from a lambda + | ArrayLambda SMTLambda -- An array value, created from a lambda | ReadArray -- Reading an array value | WriteArray -- Writing to an array deriving (Eq, Ord, Generic, G.Data, NFData) @@ -519,22 +522,38 @@ show (RegExEq r1 r2) = "(= " ++ regExpToSMTString r1 ++ " " ++ regExpToSMTString r2 ++ ")" show (RegExNEq r1 r2) = "(distinct " ++ regExpToSMTString r1 ++ " " ++ regExpToSMTString r2 ++ ")" +-- | For now, we represent lambda functions in op with their SMTLib equivalent strings. +-- This might change in the future. +newtype SMTLambda = SMTLambda String + deriving (Eq, Ord, G.Data, Generic) + deriving newtype NFData + +-- | Simple show instance for SMTLambda +instance Show SMTLambda where + show (SMTLambda s) = s + -- | Sequence operations. -data SeqOp = SeqConcat -- ^ See StrConcat - | SeqLen -- ^ See StrLen - | SeqUnit -- ^ See StrUnit - | SeqNth -- ^ See StrNth - | SeqSubseq -- ^ See StrSubseq - | SeqIndexOf -- ^ See StrIndexOf - | SeqContains -- ^ See StrContains - | SeqPrefixOf -- ^ See StrPrefixOf - | SeqSuffixOf -- ^ See StrSuffixOf - | SeqReplace -- ^ See StrReplace - | SeqMap String -- ^ Mapping over sequences - | SeqMapI String -- ^ Mapping over sequences with offset - | SeqFoldLeft String -- ^ Folding of sequences - | SeqFoldLeftI String -- ^ Folding of sequences with offset - | SBVReverse Kind -- ^ Reversal of sequences. NB. Also works for strings; hence the name. +data SeqOp = SeqConcat -- ^ See StrConcat + | SeqLen -- ^ See StrLen + | SeqUnit -- ^ See StrUnit + | SeqNth -- ^ See StrNth + | SeqSubseq -- ^ See StrSubseq + | SeqIndexOf -- ^ See StrIndexOf + | SeqContains -- ^ See StrContains + | SeqPrefixOf -- ^ See StrPrefixOf + | SeqSuffixOf -- ^ See StrSuffixOf + | SeqReplace -- ^ See StrReplace + -- Polymorphic and higher order functions + | SBVReverse Kind -- ^ reverse k. Where k is either [a] or String. Reverses the argument, accordingly. + | SBVZip Kind Kind -- ^ zip a b. Where we zip [a] and [b] to produce [(a, b)] + | SBVZipWith Kind Kind Kind SMTLambda -- ^ zipWith a b c fun. Where fun :: a -> b -> c, and zipWith :: (a -> b -> c) -> [a] -> [b] -> [c] + | SBVMap Kind Kind SMTLambda -- ^ map a b fun. Where fun :: a -> b, and map :: (a -> b) -> [a] -> [b] + | SBVFoldl Kind Kind SMTLambda -- ^ foldl a b fun. Where fun :: b -> a -> b, and foldl :: (b -> a -> b) -> b -> [a] -> b + | SBVFoldr Kind Kind SMTLambda -- ^ foldr a b fun. Where fun :: a -> b -> b, and foldr :: (a -> b -> b) -> b -> [a] -> b + | SBVFilter Kind SMTLambda -- ^ filter a fun. Where fun :: a -> Bool, and filter :: (a -> Bool) -> [a] -> [a] + | SBVAll Kind SMTLambda -- ^ all a fun. Where fun :: a -> Bool, and all :: (a -> Bool) -> [a] -> Bool + | SBVAny Kind SMTLambda -- ^ any a fun. Where fun :: a -> Bool, and any :: (a -> Bool) -> [a] -> Bool + | SBVConcat Kind -- ^ concat a. Where we concat [[a]] to get [a] (a is the inside-element type) deriving (Eq, Ord, G.Data, NFData, Generic) -- | Show instance for SeqOp. Again, mapping is important. @@ -549,17 +568,26 @@ show SeqPrefixOf = "seq.prefixof" show SeqSuffixOf = "seq.suffixof" show SeqReplace = "seq.replace" - show (SeqMap s) = "seq.map " ++ s - show (SeqMapI s) = "seq.mapi " ++ s - show (SeqFoldLeft s) = "seq.foldl " ++ s - show (SeqFoldLeftI s) = "seq.foldli " ++ s - -- Note: This isn't part of SMTLib, we explicitly handle it - show (SBVReverse k) = let sk = show k - ssk | any isSpace sk = '(' : sk ++ ")" - | True = sk - in "sbv.reverse @" ++ ssk + -- Note: The followings aren't part of SMTLib, we explicitly handle them + show (SBVReverse a) = funcWithKind "sbv.reverse" a Nothing + show (SBVZip a b) = funcWithKind "sbv.zip" (KTuple [a, b]) Nothing + show (SBVZipWith a b c f) = funcWithKind "sbv.zipWith" (KTuple [a, b, c]) (Just f) + show (SBVMap a b f) = funcWithKind "sbv.map" (KTuple [a, b]) (Just f) + show (SBVFoldl a b f) = funcWithKind "sbv.foldl" (KTuple [a, b]) (Just f) + show (SBVFoldr a b f) = funcWithKind "sbv.foldr" (KTuple [a, b]) (Just f) + show (SBVFilter a f) = funcWithKind "sbv.filter" a (Just f) + show (SBVAll a f) = funcWithKind "sbv.all" a (Just f) + show (SBVAny a f) = funcWithKind "sbv.any" a (Just f) + show (SBVConcat a) = funcWithKind "sbv.concat" a Nothing +-- helper for above +funcWithKind :: String -> Kind -> Maybe SMTLambda -> String +funcWithKind f k mbExtra = f ++ " @" ++ ssk ++ maybe "" (\l -> ' ' : show l) mbExtra + where sk = show k + ssk | any isSpace sk = '(' : sk ++ ")" + | True = sk + -- | Set operations. data SetOp = SetEqual | SetMember @@ -602,7 +630,7 @@ show (KindCast fr to) = "cast_" ++ show fr ++ "_" ++ show to show (Uninterpreted i) = "[uninterpreted] " ++ i - show (QuantifiedBool _ i) = "[quantified boolean] " ++ i + show (QuantifiedBool i) = "[quantified boolean] " ++ i show (Label s) = "[label] " ++ s @@ -638,7 +666,7 @@ show (MaybeIs k False) = "(_ is (nothing_SBVMaybe () " ++ show (KMaybe k) ++ "))" show (MaybeIs k True ) = "(_ is (just_SBVMaybe (" ++ show k ++ ") " ++ show (KMaybe k) ++ "))" show MaybeAccess = "get_just_SBVMaybe" - show (ArrayLambda s) = s + show (ArrayLambda s) = show s show ReadArray = "select" show WriteArray = "store" @@ -862,11 +890,12 @@ data ProgInfo = ProgInfo { hasQuants :: Bool , progSpecialRels :: [SpecialRelOp] , progTransClosures :: [(String, String)] + , progSpecialFuncs :: [Op] -- functions that need to be generated, like list reverse/all/any/filter } deriving G.Data instance NFData ProgInfo where - rnf (ProgInfo a b c) = rnf a `seq` rnf b `seq` rnf c + rnf (ProgInfo a b c d) = rnf a `seq` rnf b `seq` rnf c `seq` rnf d deriving instance G.Data CallStack deriving instance G.Data SrcLoc @@ -1015,7 +1044,7 @@ -- | Different means of running a symbolic piece of code data SBVRunMode = SMTMode QueryContext IStage Bool SMTConfig -- ^ In regular mode, with a stage. Bool is True if this is SAT. | CodeGen -- ^ Code generation mode. - | LambdaGen Int -- ^ Inside a lambda-expression at level + | LambdaGen (Maybe Int) -- ^ Inside a lambda-expression at level. If Nothing, then closed lambda. | Concrete (Maybe (Bool, [(NamedSymVar, CV)])) -- ^ Concrete simulation mode, with given environment if any. If Nothing: Random. -- Show instance for SBVRunMode; debugging purposes only @@ -1138,8 +1167,8 @@ -- can be found this way. lookupInput :: Eq a => (a -> SV) -> SV -> S.Seq a -> Maybe a lookupInput f sv ns - | l == 0 = res - | True = Nothing -- l != 0, a lambda var, so we ignore + | l == Just 0 = res + | True = Nothing -- l != Just 0, a lambda var, whether top-level or in a scope, so we ignore where (_, l, i) = getId (swNodeId sv) svs = fmap f ns @@ -1154,12 +1183,10 @@ data SMTDef = SMTDef String -- ^ Defined functions -- name Kind -- ^ Final kind of the definition (resulting kind, not the params) [String] -- ^ other definitions it refers to - [Op] -- ^ ops used in it, in case we need to generate extra defs (Maybe String) -- ^ parameter string (Int -> String) -- ^ Body, in SMTLib syntax, given the tab amount | SMTLam Kind -- ^ Final kind of the definition (resulting kind, not the params) [String] -- ^ Anonymous function -- other definitions it refers to - [Op] -- ^ ops used in it, in case we need to generate extra defs (Maybe String) -- ^ parameter string (Int -> String) -- ^ Body, in SMTLib syntax, given the tab amount deriving G.Data @@ -1167,8 +1194,8 @@ -- | For debug purposes instance Show SMTDef where show d = case d of - SMTDef nm fk frees _ p body -> shDef (Just nm) fk frees p body - SMTLam fk frees _ p body -> shDef Nothing fk frees p body + SMTDef nm fk frees p body -> shDef (Just nm) fk frees p body + SMTLam fk frees p body -> shDef Nothing fk frees p body where shDef mbNm fk frees p body = unlines [ "-- User defined function: " ++ fromMaybe "Anonymous" mbNm , "-- Final return type : " ++ show fk , "-- Refers to : " ++ intercalate ", " frees @@ -1179,13 +1206,13 @@ -- The name of this definition smtDefGivenName :: SMTDef -> Maybe String -smtDefGivenName (SMTDef n _ _ _ _ _) = Just n -smtDefGivenName SMTLam{} = Nothing +smtDefGivenName (SMTDef n _ _ _ _) = Just n +smtDefGivenName SMTLam{} = Nothing -- | NFData instance for SMTDef instance NFData SMTDef where - rnf (SMTDef n fk frees ops params body) = rnf n `seq` rnf fk `seq` rnf frees `seq` rnf ops `seq` rnf params `seq` rnf body - rnf (SMTLam fk frees ops params body) = rnf fk `seq` rnf frees `seq` rnf ops `seq` rnf params `seq` rnf body + rnf (SMTDef n fk frees params body) = rnf n `seq` rnf fk `seq` rnf frees `seq` rnf params `seq` rnf body + rnf (SMTLam fk frees params body) = rnf fk `seq` rnf frees `seq` rnf params `seq` rnf body -- | The state of the symbolic interpreter data State = State { sbvContext :: SBVContext @@ -1198,7 +1225,7 @@ , rCInfo :: IORef [(String, CV)] , rObservables :: IORef (S.Seq (Name, CV -> Bool, SV)) , rctr :: IORef Int - , rLambdaLevel :: IORef Int + , rLambdaLevel :: IORef (Maybe Int) -- If Nothing, then top-level lambda , rUsedKinds :: IORef KindSet , rUsedLbls :: IORef (Set.Set String) , rinps :: IORef Inputs @@ -1336,6 +1363,10 @@ | UISMT SMTDef -- SMTLib, first argument are the free-variables in it | UICgC [String] -- Code-gen, currently only C +-- | Is the name given by the user for the uninterpreted constant a prefix or a full name? +data UIName = UIGiven String -- ^ Full name + | UIPrefix String -- ^ Prefix + -- | Uninterpreted constants and functions. An uninterpreted constant is -- a value that is indexed by its name. The only property the prover assumes -- about these values are that they are equivalent to themselves; i.e., (for @@ -1343,68 +1374,78 @@ -- We support uninterpreted-functions as a general means of black-box'ing -- operations that are /irrelevant/ for the purposes of the proof; i.e., when -- the proofs can be performed without any knowledge about the function itself. -svUninterpreted :: Kind -> String -> UICodeKind -> [SVal] -> SVal +svUninterpreted :: Kind -> UIName -> UICodeKind -> [SVal] -> SVal svUninterpreted k nm code args = svUninterpretedGen k nm code args Nothing -svUninterpretedNamedArgs :: Kind -> String -> UICodeKind -> [(SVal, String)] -> SVal +svUninterpretedNamedArgs :: Kind -> UIName -> UICodeKind -> [(SVal, String)] -> SVal svUninterpretedNamedArgs k nm code args = svUninterpretedGen k nm code (map fst args) (Just (map snd args)) -svUninterpretedGen :: Kind -> String -> UICodeKind -> [SVal] -> Maybe [String] -> SVal +svUninterpretedGen :: Kind -> UIName -> UICodeKind -> [SVal] -> Maybe [String] -> SVal svUninterpretedGen k nm code args mbArgNames = SVal k $ Right $ cache result where result st = do let ty = SBVType (map kindOf args ++ [k]) - newUninterpreted st (nm, mbArgNames) ty code + nm' <- newUninterpreted st nm mbArgNames ty code sws <- mapM (svToSV st) args mapM_ forceSVArg sws - newExpr st k $ SBVApp (Uninterpreted nm) sws + newExpr st k $ SBVApp (Uninterpreted nm') sws --- | Create a new uninterpreted symbol, possibly with user given code -newUninterpreted :: State -> (String, Maybe [String]) -> SBVType -> UICodeKind -> IO () -newUninterpreted st (nm, mbArgNames) t uiCode - | not (isInternal || case nm of - [] -> False - h:tl -> enclosed || (isAlpha h && all validChar tl)) - = error $ "Bad uninterpreted constant name: " ++ show nm ++ ". Must be a valid SMTLib identifier." - | True - = do uiMap <- readIORef (rUIMap st) +-- | Create a new uninterpreted symbol, possibly with user given code. This function might change +-- the name given, putting bars around it if needed. That's the name returned. +newUninterpreted :: State -> UIName -> Maybe [String] -> SBVType -> UICodeKind -> IO String +newUninterpreted st uiName mbArgNames t uiCode = do - isCurried <- case uiCode of - UINone c -> pure c - UISMT d -> do modifyState st rDefns (\defs -> (d, t) : filter (\(o, _) -> smtDefGivenName o /= Just nm) defs) - $ noInteractive [ "Defined functions (smtFunction):" - , " Name: " ++ nm - , " Type: " ++ show t - , "" - , "You should use these functions at least once the query part starts" - , "and then use them in the query section as usual." - ] - pure True - UICgC c -> -- No need to record the code in interactive mode: CodeGen doesn't use interactive - do modifyState st rCgMap (Map.insert nm c) (return ()) - pure True + uiMap <- readIORef (rUIMap st) - case nm `Map.lookup` uiMap of - Just (_, _, t') -> checkType t' (return ()) - Nothing -> modifyState st rUIMap (Map.insert nm (isCurried, mbArgNames, t)) - $ modifyIncState st rNewUIs - (\newUIs -> case nm `Map.lookup` newUIs of - Just (_, _, t') -> checkType t' newUIs - Nothing -> Map.insert nm (isCurried, mbArgNames, t) newUIs) - where checkType :: SBVType -> r -> r - checkType t' cont - | t /= t' = error $ "Uninterpreted constant " ++ show nm ++ " used at incompatible types\n" - ++ " Current type : " ++ show t ++ "\n" - ++ " Previously used at: " ++ show t' - | True = cont + let candName = case uiName of + UIGiven n -> n + UIPrefix pre -> let suffix 0 = pre + suffix i = pre ++ show i + in case [cand | i <- [0::Int ..], let cand = suffix i, cand `Map.notMember` uiMap] of + (n:_) -> n + [] -> error $ "newUninterpreted: Can't generate a unique name for prefix: " ++ pre -- can't happen - validChar x = isAlphaNum x || x `elem` ("_" :: String) - enclosed = "|" `isPrefixOf` nm - && "|" `isSuffixOf` nm - && length nm > 2 - && not (any (`elem` ("|\\" :: String)) (drop 1 (init nm))) + -- determine the final name + nm = case () of + () | "__internal_sbv_" `isPrefixOf` candName -> candName -- internal names go thru + () | needsBars candName -> '|' : candName ++ "|" -- surround with bars if not legitimate in SMTLib + () -> candName - -- let internal names go through - isInternal = "__internal_sbv_" `isPrefixOf` nm + extraComment = case uiName of + UIGiven n | nm /= n -> " (Given: " ++ n ++ ")" + UIPrefix n | not (nm `isPrefixOf` n) -> " (Given prefix: " ++ n ++ ")" + _ -> "" + isCurried <- case uiCode of + UINone c -> pure c + UISMT d -> do modifyState st rDefns (\defs -> (d, t) : filter (\(o, _) -> smtDefGivenName o /= Just nm) defs) + $ noInteractive [ "Defined functions (smtFunction):" + , " Name: " ++ nm ++ extraComment + , " Type: " ++ show t + , "" + , "You should explicitly register these functions by calling" + , "the function 'registerFunction' on them before starting the query section." + ] + pure True + UICgC c -> -- No need to record the code in interactive mode: CodeGen doesn't use interactive + do modifyState st rCgMap (Map.insert nm c) (return ()) + pure True + + let checkType :: SBVType -> r -> r + checkType t' cont + | t /= t' = error $ "Uninterpreted constant " ++ show nm ++ extraComment ++ " used at incompatible types\n" + ++ " Current type : " ++ show t ++ "\n" + ++ " Previously used at: " ++ show t' + | True = cont + + case nm `Map.lookup` uiMap of + Just (_, _, t') -> checkType t' (return ()) + Nothing -> modifyState st rUIMap (Map.insert nm (isCurried, mbArgNames, t)) + $ modifyIncState st rNewUIs + (\newUIs -> case nm `Map.lookup` newUIs of + Just (_, _, t') -> checkType t' newUIs + Nothing -> Map.insert nm (isCurried, mbArgNames, t) newUIs) + + pure nm + -- | Add a new sAssert based constraint addAssertion :: State -> Maybe CallStack -> String -> SV -> IO () addAssertion st cs msg cond = modifyState st rAsserts ((msg, cs, cond):) @@ -1416,13 +1457,13 @@ -- | Create an internal variable, which acts as an input but isn't visible to the user. -- Such variables are existentially quantified in a SAT context, and universally quantified -- in a proof context. -internalVariable :: State -> Kind -> IO SV -internalVariable st k = do NamedSymVar sv nm <- newSV st k - let n = "__internal_sbv_" <> nm - v = NamedSymVar sv n - modifyState st rinps (addUserInput sv n) $ modifyIncState st rNewInps (v :) - return sv -{-# INLINE internalVariable #-} +newInternalVariable :: State -> Kind -> IO SV +newInternalVariable st k = do NamedSymVar sv nm <- newSV st k + let n = "__internal_sbv_" <> nm + v = NamedSymVar sv n + modifyState st rinps (addUserInput sv n) $ modifyIncState st rNewInps (v :) + return sv +{-# INLINE newInternalVariable #-} -- | Create a variable to be used in a constraint-expression quantVar :: Quantifier -> State -> Kind -> IO SV @@ -1456,7 +1497,7 @@ -- allow for this. registerKind :: State -> Kind -> IO () registerKind st k - | KUserSort sortName _ <- k, map toLower sortName `elem` smtLibReservedNames + | KUserSort sortName _ <- k, isReserved sortName = error $ "SBV: " ++ show sortName ++ " is a reserved sort; please use a different name." | True = do -- Adding a kind to the incState is tricky; we only need to add it @@ -1504,7 +1545,7 @@ -- | Register a new label with the system, making sure they are unique and have no '|'s in them registerLabel :: String -> State -> String -> IO () registerLabel whence st nm - | map toLower nm `elem` smtLibReservedNames + | isReserved nm = err "is a reserved string; please use a different name." | '|' `elem` nm = err "contains the character `|', which is not allowed!" @@ -1518,6 +1559,13 @@ where err w = error $ "SBV (" ++ whence ++ "): " ++ show nm ++ " " ++ w +-- We need to auto-generate certain functions, so keep track of them here +registerSpecialFunction :: State -> Op -> IO () +registerSpecialFunction st o = + do progInfo <- readIORef (rProgInfo (getRootState st)) + let upd p@ProgInfo{progSpecialFuncs} = p{progSpecialFuncs = o : progSpecialFuncs} + unless (o `elem` progSpecialFuncs progInfo) $ modifyState st rProgInfo upd (pure ()) + -- | Create a new constant; hash-cons as necessary newConst :: State -> CV -> IO SV newConst st c = do @@ -1569,12 +1617,14 @@ -- This isn't a full solution, but handles the common case (hopefully!) checkConsistent :: SV -> SBVExpr -> IO () checkConsistent lhs (SBVApp _ args) = mapM_ check args - where SV _ (NodeId (lhsContext, lambdaLevel, lhsId)) = lhs - check (SV _ (NodeId (rhsContext, ll, ni))) + where SV _ (NodeId (lhsContext, mbLambdaLevel, lhsId)) = lhs + check (SV _ (NodeId (rhsContext, mbLL, ni))) | lhsContext `compatibleContext` rhsContext && lambdaLevel >= ll && (lambdaLevel /= ll || lhsId > ni) = pure () | True = contextMismatchError lhsContext rhsContext (Just (lambdaLevel, lhsId)) (Just (ll, ni)) + where lambdaLevel = fromMaybe 0 mbLambdaLevel + ll = fromMaybe 0 mbLL {-# INLINE checkConsistent #-} -- | Are these compatible contexts? Either the same, or one of them is global @@ -1817,14 +1867,15 @@ progInfo <- newIORef ProgInfo { hasQuants = False , progSpecialRels = [] , progTransClosures = [] + , progSpecialFuncs = [] } rm <- newIORef currentRunMode ctr <- newIORef (-2) -- start from -2; False and True will always occupy the first two elements lambda <- newIORef $ case currentRunMode of - SMTMode{} -> 0 - CodeGen{} -> 0 - Concrete{} -> 0 - LambdaGen i -> i + SMTMode{} -> Just 0 + CodeGen{} -> Just 0 + Concrete{} -> Just 0 + LambdaGen mbi -> mbi cInfo <- newIORef [] observes <- newIORef mempty pgm <- newIORef (SBVPgm S.empty) @@ -1904,6 +1955,7 @@ , "*** Refers to: " ++ show level1 , "*** And also : " ++ show level2 ] + rest = [ "***" , "*** This happens if you call a proof-function (prove/sat/runSMT/isSatisfiable) etc." , "*** while another one is in execution, or use results from one such call in another." @@ -1925,7 +1977,7 @@ | True = contextMismatchError (sbvContext st) ctx Nothing Nothing - mapM_ check $ nub $ G.universeBi res + mapM_ check $ nubOrd $ G.universeBi res return (r, res) @@ -2137,9 +2189,6 @@ show (SMTLibPgm _ pgm _) = intercalate "\n" pgm -- Other Technicalities.. -instance NFData CV where - rnf (CV x y) = x `seq` y `seq` () - instance NFData GeneralizedCV where rnf (ExtendedCV e) = e `seq` () rnf (RegularCV c) = c `seq` () @@ -2160,7 +2209,6 @@ `seq` rnf inps `seq` rnf consts `seq` rnf tbls `seq` rnf uis `seq` rnf axs `seq` rnf pgm `seq` rnf cstr `seq` rnf asserts `seq` rnf outs -instance NFData Kind where rnf a = seq a () instance NFData SV where rnf a = seq a () instance NFData SBVExpr where rnf a = seq a () instance NFData Quantifier where rnf a = seq a () @@ -2202,7 +2250,7 @@ , supportsCustomQueries :: Bool -- ^ Supports interactive queries per SMT-Lib? , supportsGlobalDecls :: Bool -- ^ Supports global declarations? (Needed for push-pop.) , supportsDataTypes :: Bool -- ^ Supports datatypes? - , supportsFoldAndMap :: Bool -- ^ Does it support fold and map? + , supportsLambdas :: Bool -- ^ Does it support lambdas? , supportsSpecialRels :: Bool -- ^ Does it support special relations (orders, transitive closure etc.) , supportsDirectAccessors :: Bool -- ^ Supports data-type accessors without full ascription? , supportsFlattenedModels :: Maybe [String] -- ^ Supports flattened model output? (With given config lines.) @@ -2251,9 +2299,20 @@ , solverSetOptions :: [SMTOption] -- ^ Options to set as we start the solver , ignoreExitCode :: Bool -- ^ If true, we shall ignore the exit code upon exit. Otherwise we require ExitSuccess. , redirectVerbose :: Maybe FilePath -- ^ Redirect the verbose output to this file if given. If Nothing, stdout is implied. - , kdRibbonLength :: Int -- ^ Line length for KD proofs + , generateHOEquivs :: Bool -- ^ Should SBV generate function-level equivalences for firstified functions? + -- The default is False, but in certain cases this can lead the solver to loop-forever, + -- especially in KnuckleDragger proofs. In such cases, set this to True to see if it helps. + , kdOptions :: KDOptions -- ^ KnuckleDragger specific options } +-- | Configuration for KnuckleDragger +data KDOptions = KDOptions { + ribbonLength :: Int -- ^ Line length for KD proofs + , firstifyUniqueLen :: Int -- ^ Unique length used for firstified names. + , quiet :: Bool -- ^ No messages what-so-ever + , measureTime :: Bool -- ^ Print time/statistics. If quiet is True, then measureTime is ignored. + } + -- | Ignore internal names and those the user told us to mustIgnoreVar :: SMTConfig -> String -> Bool mustIgnoreVar cfg s = "__internal_sbv" `isPrefixOf` s || isNonModelVar cfg s @@ -2281,6 +2340,10 @@ -- difficult for SBV to figure out what it means } deriving Show + +-- | Is it the case that the model is really uninteresting? This is the case when there are no assocs nor ui's +isEmptyModel :: SMTModel -> Bool +isEmptyModel SMTModel{modelAssocs, modelUIFuns} = null modelAssocs && null modelUIFuns -- | The result of an SMT solver call. Each constructor is tagged with -- the 'SMTConfig' that created it so that further tools can inspect it diff --git a/Data/SBV/Internals.hs b/Data/SBV/Internals.hs --- a/Data/SBV/Internals.hs +++ b/Data/SBV/Internals.hs @@ -25,7 +25,7 @@ module Data.SBV.Internals ( -- * Running symbolic programs /manually/ - Result(..), SBVRunMode(..), IStage(..), QueryContext(..), VarContext(..), mkNewState + Result(..), SBVRunMode(..), IStage(..), QueryContext(..), VarContext(..), SatModel(..), mkNewState -- * Solver capabilities , SolverCapabilities(..) @@ -65,7 +65,7 @@ , svFloatingPointAsSWord -- * lambdas and axioms - , lambda, lambdaStr, namedLambda, namedLambdaStr, constraint, constraintStr, Lambda(..), Constraint(..) + , lambda, lambdaStr, namedLambda, namedLambdaStr, constraint, constraintStr, Lambda(..), Constraint(..), LambdaScope(..) ) where import Control.Monad.IO.Class (MonadIO) @@ -83,7 +83,7 @@ import Data.SBV.Compilers.C (compileToC', compileToCLib') import Data.SBV.Compilers.CodeGen -import Data.SBV.SMT.SMT (genParse, showModel) +import Data.SBV.SMT.SMT (genParse, showModel, SatModel(..)) import Data.SBV.Provers.Prover (ProvableM, SatisfiableM) diff --git a/Data/SBV/Lambda.hs b/Data/SBV/Lambda.hs --- a/Data/SBV/Lambda.hs +++ b/Data/SBV/Lambda.hs @@ -24,9 +24,9 @@ lambda, lambdaStr , namedLambda, namedLambdaStr , constraint, constraintStr + , LambdaScope(..) ) where - import Control.Monad (join) import Control.Monad.Trans (liftIO, MonadIO) @@ -40,22 +40,45 @@ import Data.IORef (readIORef, modifyIORef') import Data.List +import Data.Maybe (fromMaybe) import qualified Data.Foldable as F +import qualified Data.Set as Set import qualified Data.Generics.Uniplate.Data as G +-- | What's the scope of the generated lambda? +data LambdaScope = HigherOrderArg -- This lambda will be firstified, hence can't have any free variables + | TopLevel -- This lambda is used to represent a quantified axiom, can have free vars + data Defn = Defn [String] -- The uninterpreted names referred to in the body + [String] -- Free variables (i.e., not uninterpreted nor bound in the definition itself) (Maybe [(Quantifier, String)]) -- Param declaration groups, if any - [Op] -- All ops used in the definition (Int -> String) -- Body, given the tab amount. -- | Maka a new substate from the incoming state, sharing parts as necessary -inSubState :: MonadIO m => State -> (State -> m b) -> m b -inSubState inState comp = do - ll <- liftIO $ readIORef (rLambdaLevel inState) - stEmpty <- S.mkNewState (stCfg inState) (LambdaGen (ll + 1)) +inSubState :: MonadIO m => LambdaScope -> State -> (State -> m b) -> m b +inSubState scope inState comp = do + let noNesting = error $ unlines [ "" + , "*** Data.SBV.Lambda: Detected nested lambda-definitions." + , "***" + , "*** SBV uses firstification to deal-with lambdas, and SMTLib's first-order nature does not allow" + , "*** for easy translation of nested lambdas. As SMTLib gets higher-order features, SBV will eventually" + , "*** relax this restriction. In the mean-time, please rewrite your program without using nested-lambdas" + , "*** if possible. If this workaround isn't applicable, please report this as a use-case for further" + , "*** possible enhancements." + ] + + newLevel <- do ll <- liftIO $ readIORef (rLambdaLevel inState) + pure $ case ll of + Nothing -> noNesting + Just i -> case scope of + HigherOrderArg -> Nothing + TopLevel -> Just $ i + 1 + + stEmpty <- S.mkNewState (stCfg inState) (LambdaGen newLevel) + let share fld = fld inState -- reuse the field from the parent-context fresh fld = fld stEmpty -- create a new field here @@ -126,51 +149,74 @@ -- | Generic creator for anonymous lamdas. -lambdaGen :: (MonadIO m, Lambda (SymbolicT m) a) => (Defn -> b) -> State -> Kind -> a -> m b -lambdaGen trans inState fk f = inSubState inState $ \st -> trans <$> convert st fk (mkLambda st f) +lambdaGen :: (MonadIO m, Lambda (SymbolicT m) a) => LambdaScope -> (Defn -> b) -> State -> Kind -> a -> m b +lambdaGen scope trans inState fk f = inSubState scope inState $ \st -> handle <$> convert st fk (mkLambda st f) + where handle d@(Defn _ frees _ _) = + case scope of + TopLevel -> trans d + HigherOrderArg -> if null frees + then trans d + else error $ unlines [ "" + , "*** Data.SBV.Lambda: Detected free variables passed to a lambda." + , "***" + , "*** Free vars : " ++ unwords frees + , "*** Definition: " ++ shift (lines (sh d)) + , "***" + , "*** In certain contexts, SBV only allows closed-lambdas, i.e., those that do not have any free variables in." + , "***" + , "*** Please rewrite your program to pass the free variable as an explicit argument to the lambda if possible." + , "*** If this workaround isn't applicable, please report this as a use-case for further possible enhancements." + ] + sh (Defn _unints _frees Nothing body) = body 0 + sh (Defn _unints _frees (Just params) body) = "(lambda " ++ extractAllUniversals params ++ "\n" ++ body 2 ++ ")" + + shift [] = [] + shift (x:xs) = intercalate "\n" (x : map tab xs) + where tab s = "*** " ++ s + -- | Create an SMTLib lambda, in the given state. -lambda :: (MonadIO m, Lambda (SymbolicT m) a) => State -> Kind -> a -> m SMTDef -lambda inState fk = lambdaGen mkLam inState fk - where mkLam (Defn frees params ops body) = SMTLam fk frees ops (extractAllUniversals <$> params) body +lambda :: (MonadIO m, Lambda (SymbolicT m) a) => State -> LambdaScope -> Kind -> a -> m SMTDef +lambda inState scope fk = lambdaGen scope mkLam inState fk + where mkLam (Defn unints _frees params body) = SMTLam fk unints (extractAllUniversals <$> params) body --- | Create an anonymous lambda, rendered as n SMTLib string -lambdaStr :: (MonadIO m, Lambda (SymbolicT m) a) => State -> Kind -> a -> m String -lambdaStr = lambdaGen mkLam - where mkLam (Defn _frees Nothing _ops body) = body 0 - mkLam (Defn _frees (Just params) _ops body) = "(lambda " ++ extractAllUniversals params ++ "\n" ++ body 2 ++ ")" +-- | Create an anonymous lambda, rendered as n SMTLib string. The kind passed is the kind of the final result. +lambdaStr :: (MonadIO m, Lambda (SymbolicT m) a) => State -> LambdaScope -> Kind -> a -> m SMTLambda +lambdaStr st scope k a = SMTLambda <$> lambdaGen scope mkLam st k a + where mkLam (Defn _unints _frees Nothing body) = body 0 + mkLam (Defn _unints _frees (Just params) body) = "(lambda " ++ extractAllUniversals params ++ "\n" ++ body 2 ++ ")" -- | Generaic creator for named functions, -namedLambdaGen :: (MonadIO m, Lambda (SymbolicT m) a) => (Defn -> b) -> State -> Kind -> a -> m b -namedLambdaGen trans inState fk f = inSubState inState $ \st -> trans <$> convert st fk (mkLambda st f) +namedLambdaGen :: (MonadIO m, Lambda (SymbolicT m) a) => LambdaScope -> (Defn -> b) -> State -> Kind -> a -> m b +namedLambdaGen scope trans inState fk f = inSubState scope inState $ \st -> trans <$> convert st fk (mkLambda st f) -- | Create a named SMTLib function, in the given state. -namedLambda :: (MonadIO m, Lambda (SymbolicT m) a) => State -> String -> Kind -> a -> m SMTDef -namedLambda inState nm fk = namedLambdaGen mkDef inState fk - where mkDef (Defn frees params ops body) = SMTDef nm fk frees ops (extractAllUniversals <$> params) body +namedLambda :: (MonadIO m, Lambda (SymbolicT m) a) => LambdaScope -> State -> String -> Kind -> a -> m SMTDef +namedLambda scope inState nm fk = namedLambdaGen scope mkDef inState fk + where mkDef (Defn unints _frees params body) = SMTDef nm fk unints (extractAllUniversals <$> params) body -- | Create a named SMTLib function, in the given state, string version -namedLambdaStr :: (MonadIO m, Lambda (SymbolicT m) a) => State -> String -> SBVType -> a -> m String -namedLambdaStr inState nm t = namedLambdaGen mkDef inState fk - where mkDef (Defn frees params ops body) = concat $ declUserFuns [(SMTDef nm fk frees ops (extractAllUniversals <$> params) body, t)] +namedLambdaStr :: (MonadIO m, Lambda (SymbolicT m) a) => LambdaScope -> State -> String -> SBVType -> a -> m String +namedLambdaStr scope inState nm t = namedLambdaGen scope mkDef inState fk + where mkDef (Defn unints _frees params body) = concat $ declUserFuns [(SMTDef nm fk unints (extractAllUniversals <$> params) body, t)] fk = case t of SBVType [] -> error $ "namedLambdaStr: Invalid type for " ++ show nm ++ ", empty!" SBVType xs -> last xs -- | Generic constraint generator. -constraintGen :: (MonadIO m, Constraint (SymbolicT m) a) => ([String] -> [Op] -> (Int -> String) -> b) -> State -> a -> m b -constraintGen trans inState@State{rProgInfo} f = do +constraintGen :: (MonadIO m, Constraint (SymbolicT m) a) => LambdaScope -> ([String] -> (Int -> String) -> b) -> State -> a -> m b +constraintGen scope trans inState@State{rProgInfo} f = do -- indicate we have quantifiers liftIO $ modifyIORef' rProgInfo (\u -> u{hasQuants = True}) - let mkDef (Defn deps Nothing ops body) = trans deps ops body - mkDef (Defn deps (Just params) ops body) = trans deps ops $ \i -> unwords (map mkGroup params) ++ "\n" - ++ body (i + 2) - ++ replicate (length params) ')' + let mkDef (Defn deps _frees Nothing body) = trans deps body + mkDef (Defn deps _frees (Just params) body) = trans deps $ \i -> unwords (map mkGroup params) ++ "\n" + ++ body (i + 2) + ++ replicate (length params) ')' mkGroup (ALL, s) = "(forall " ++ s mkGroup (EX, s) = "(exists " ++ s - inSubState inState $ \st -> mkDef <$> convert st KBool (mkConstraint st f >>= output >> pure ()) + inSubState scope inState $ \st -> mkDef <$> convert st KBool (mkConstraint st f >>= output >> pure ()) -- | A constraint can be turned into a boolean instance Constraint Symbolic a => QuantifiedBool a where @@ -178,16 +224,18 @@ where f st = liftIO $ constraint st qb -- | Generate a constraint. +-- We allow free variables here (first arg of constraintGen). This might prove to be not kosher! constraint :: (MonadIO m, Constraint (SymbolicT m) a) => State -> a -> m SV -constraint st = join . constraintGen mkSV st - where mkSV _deps ops d = liftIO $ newExpr st KBool (SBVApp (QuantifiedBool ops (d 0)) []) +constraint st = join . constraintGen TopLevel mkSV st + where mkSV _deps d = liftIO $ newExpr st KBool (SBVApp (QuantifiedBool (d 0)) []) -- | Generate a constraint, string version +-- We allow free variables here (first arg of constraintGen). This might prove to be not kosher! constraintStr :: (MonadIO m, Constraint (SymbolicT m) a) => State -> a -> m String -constraintStr = constraintGen toStr - where toStr deps _ body = intercalate "\n" [ "; user defined axiom: " ++ depInfo deps - , "(assert " ++ body 2 ++ ")" - ] +constraintStr = constraintGen TopLevel toStr + where toStr deps body = intercalate "\n" [ "; user defined axiom: " ++ depInfo deps + , "(assert " ++ body 2 ++ ")" + ] depInfo [] = "" depInfo ds = "[Refers to: " ++ intercalate ", " ds ++ "]" @@ -201,7 +249,7 @@ pure $ toLambda level curProgInfo (stCfg st) expectedKind res -- | Convert the result of a symbolic run to a more abstract representation -toLambda :: Int -> ProgInfo -> SMTConfig -> Kind -> Result -> Defn +toLambda :: Maybe Int -> ProgInfo -> SMTConfig -> Kind -> Result -> Defn toLambda level curProgInfo cfg expectedKind result@Result{resAsgns = SBVPgm asgnsSeq} = sh result where tbd xs = error $ unlines $ "*** Data.SBV.lambda: Unsupported construct." : map ("*** " ++) ("" : xs ++ ["", report]) bad xs = error $ unlines $ "*** Data.SBV.lambda: Impossible happened." : map ("*** " ++) ("" : xs ++ ["", bugReport]) @@ -261,17 +309,26 @@ ] | True = res - where res = Defn (nub [nm | Uninterpreted nm <- G.universeBi asgnsSeq]) + where res = Defn (nub [nm | Uninterpreted nm <- G.universeBi allOps]) + frees mbParam - (nub (sort (G.universeBi asgnsSeq))) body + -- Below can simply be defined as: nub (sort (G.universeBi asgnsSeq)) + -- Alas, it turns out this is really expensive when we have nested lambdas, so we do an explicit walk + allOps = Set.toList $ foldl' (\sofar (_, SBVApp o _) -> Set.insert o sofar) Set.empty asgnsSeq + params = case is of ResultTopInps as -> bad [ "Top inputs" , " Saw: " ++ show as ] ResultLamInps xs -> map (\(q, v) -> (q, getSV v)) xs + frees = map show $ nub allUses \\ nub allDefs + where (defs, uses) = unzip [(d, u) | (d, SBVApp _ u) <- F.toList asgnsSeq] + allDefs = defs ++ map snd params ++ map fst constants + allUses = concat uses + mbParam | null params = Nothing | True = Just [(q, paramList (map snd l)) | l@((q, _) : _) <- pGroups] @@ -295,7 +352,7 @@ mkLet (s, v) = mkBind (show s) v -- Align according to level. - shift = replicate (24 + 16 * (level - 1)) ' ' + shift = replicate (24 + 16 * (fromMaybe 0 level - 1)) ' ' mkTable (((i, ak, rk), elts), _) = mkBind nm (lambdaTable (map (const ' ') nm) ak rk elts) where nm = "table" ++ show i @@ -315,12 +372,16 @@ mkLocalBind (b, Just l) = mkLet b ++ " ; " ++ l getLLI :: NodeId -> (Int, Int) - getLLI (NodeId (_, l, i)) = (l, i) + getLLI (NodeId (_, mbl, i)) = (fromMaybe 0 mbl, i) -- if we have just one definition returning it, and if the expression itself is simple enough (single-line), simplify + -- If the line has new-lines we typically don't want to mess with it, but that causes a memory leak + -- (see https://github.com/LeventErkok/sbv/issues/733), so only do it if we're being verbose for debugging purposes. + mkPretty = verbose cfg + simpleBody :: [((SV, String), Maybe String)] -> SV -> Maybe String - simpleBody [((v, e), Nothing)] o | v == o, '\n' `notElem` e = Just e - simpleBody _ _ = Nothing + simpleBody [((v, e), Nothing)] o | v == o, not mkPretty || '\n' `notElem` e = Just e + simpleBody _ _ = Nothing assignments = F.toList (pgmAssignments pgm) @@ -336,7 +397,7 @@ where mkAsgn (sv, e@(SBVApp (Label l) _)) = ((sv, converter e), Just l) mkAsgn (sv, e) = ((sv, converter e), Nothing) - converter = cvtExp curProgInfo (capabilities (solver cfg)) rm tableMap + converter = cvtExp cfg curProgInfo (capabilities (solver cfg)) rm tableMap out :: SV diff --git a/Data/SBV/List.hs b/Data/SBV/List.hs --- a/Data/SBV/List.hs +++ b/Data/SBV/List.hs @@ -33,27 +33,28 @@ -- * Reverse , reverse -- * Mapping - , map, mapi + , map, concatMap -- * Folding - , foldl, foldr, foldli, foldri + , foldl, foldr -- * Zipping , zip, zipWith -- * Filtering , filter -- * Other list functions - , all, any + , all, any, and, or ) where import Prelude hiding (head, tail, init, length, take, drop, concat, null, elem, - notElem, reverse, (++), (!!), map, foldl, foldr, zip, zipWith, filter, all, any) + notElem, reverse, (++), (!!), map, concatMap, foldl, foldr, zip, zipWith, filter, + all, any, and, or) import qualified Prelude as P import Data.SBV.Core.Kind import Data.SBV.Core.Data hiding (StrOp(..)) import Data.SBV.Core.Model +import Data.SBV.Core.Symbolic (registerSpecialFunction) import Data.SBV.Lambda -import Data.SBV.Tuple import Data.Maybe (isNothing, catMaybes) @@ -378,9 +379,11 @@ = SBV $ SVal k $ Right $ cache r where k = kindOf l r st = do sva <- sbvToSV st l - newExpr st k (SBVApp (SeqOp (SBVReverse k)) [sva]) + let op = SeqOp (SBVReverse k) + registerSpecialFunction st op + newExpr st k (SBVApp op [sva]) --- | @`map` op s@ maps the operation on to sequence. +-- | @`map` f s@ maps the operation on to sequence. -- -- >>> map (+1) [1 .. 5 :: Integer] -- [2,3,4,5,6] :: [SInteger] @@ -399,51 +402,29 @@ -- Satisfiable. Model: -- s0 = [0,1,2] :: [Integer] map :: forall a b. (SymVal a, SymVal b) => (SBV a -> SBV b) -> SList a -> SList b -map op l +map f l | Just l' <- unliteral l, Just concResult <- concreteMap l' = literal concResult | True - = SBV $ SVal k $ Right $ cache r - where concreteMap l' = case P.map (unliteral . op . literal) l' of + = SBV $ SVal klb $ Right $ cache r + where concreteMap l' = case P.map (unliteral . f . literal) l' of xs | P.any isNothing xs -> Nothing | True -> Just (catMaybes xs) - k = kindOf (Proxy @(SList b)) + ka = kindOf (Proxy @a) + kb = kindOf (Proxy @b) + klb = kindOf (Proxy @(SList b)) r st = do sva <- sbvToSV st l - lam <- lambdaStr st (kindOf (Proxy @b)) op - newExpr st k (SBVApp (SeqOp (SeqMap lam)) [sva]) - --- | @`mapi` op s@ maps the operation on to sequence, with the counter given at each element, starting --- at the given value. In Haskell terms, it is: --- --- @ --- mapi :: (Integer -> a -> b) -> Integer -> [a] -> [b] --- mapi f i xs = zipWith f [i..] xs --- @ --- --- Note that `mapi` is definable in terms of `Data.SBV.List.zipWith`, with extra coding. The reason why SBV provides --- this function natively is because it maps to a native function in the underlying solver. So, hopefully it'll perform --- better in terms being decidable. --- --- >>> mapi (+) 10 [1 .. 5 :: Integer] --- [11,13,15,17,19] :: [SInteger] -mapi :: forall a b. (SymVal a, SymVal b) => (SInteger -> SBV a -> SBV b) -> SInteger -> SList a -> SList b -mapi op i l - | Just l' <- unliteral l, Just i' <- unliteral i, Just concResult <- concMapi i' l' - = literal concResult - | True - = SBV $ SVal k $ Right $ cache r - where concMapi b xs = case P.zipWith (\o e -> unliteral (op (literal o) (literal e))) [b ..] xs of - vs | P.any isNothing vs -> Nothing - | True -> Just (catMaybes vs) + lam <- lambdaStr st HigherOrderArg kb f + let op = SeqOp (SBVMap ka kb lam) + registerSpecialFunction st op + newExpr st klb (SBVApp op [sva]) - k = kindOf (Proxy @(SList b)) - r st = do svi <- sbvToSV st i - svl <- sbvToSV st l - lam <- lambdaStr st (kindOf (Proxy @b)) op - newExpr st k (SBVApp (SeqOp (SeqMapI lam)) [svi, svl]) +-- | @concatMap f xs@ maps f over elements and concats the result. +concatMap :: (SymVal a, SymVal b) => (SBV a -> SList b) -> SList a -> SList b +concatMap f xs = concat (map f xs) --- | @`foldl` op base s@ folds the from the left. +-- | @`foldl` f base s@ folds the from the left. -- -- >>> foldl (+) 0 [1 .. 5 :: Integer] -- 15 :: SInteger @@ -457,55 +438,27 @@ -- >>> sat $ \l -> foldl (\soFar elt -> singleton elt ++ soFar) ([] :: SList Integer) l .== [5, 4, 3, 2, 1 :: Integer] -- Satisfiable. Model: -- s0 = [1,2,3,4,5] :: [Integer] -foldl :: (SymVal a, SymVal b) => (SBV b -> SBV a -> SBV b) -> SBV b -> SList a -> SBV b -foldl op base l +foldl :: forall a b. (SymVal a, SymVal b) => (SBV b -> SBV a -> SBV b) -> SBV b -> SList a -> SBV b +foldl f base l | Just l' <- unliteral l, Just base' <- unliteral base, Just concResult <- concreteFoldl base' l' = literal concResult | True - = SBV $ SVal k $ Right $ cache r + = SBV $ SVal kb $ Right $ cache r where concreteFoldl b [] = Just b - concreteFoldl b (e:es) = case unliteral (op (literal b) (literal e)) of + concreteFoldl b (e:es) = case unliteral (literal b `f` literal e) of Nothing -> Nothing Just b' -> concreteFoldl b' es - k = kindOf base + ka = kindOf (Proxy @a) + kb = kindOf (Proxy @b) r st = do svb <- sbvToSV st base svl <- sbvToSV st l - lam <- lambdaStr st k op - newExpr st k (SBVApp (SeqOp (SeqFoldLeft lam)) [svb, svl]) - --- | @`foldli` op i base s@ folds the sequence, with the counter given at each element, starting --- at the given value. In Haskell terms, it is: --- --- @ --- foldli :: (Integer -> b -> a -> b) -> Integer -> b -> [a] -> b --- foldli f c e xs = foldl (\b (i, a) -> f i b a) e (zip [c..] xs) --- @ --- --- While this function is rather odd looking, it maps directly to the implementation in the underlying solver, --- and proofs involving it might have better decidability. --- --- >>> foldli (\i b a -> i+b+a) 10 0 [1 .. 5 :: Integer] --- 75 :: SInteger -foldli :: (SymVal a, SymVal b) => (SInteger -> SBV b -> SBV a -> SBV b) -> SInteger -> SBV b -> SList a -> SBV b -foldli op baseI baseE l - | Just l' <- unliteral l, Just baseI' <- unliteral baseI, Just baseE' <- unliteral baseE, Just concResult <- concreteFoldli baseI' baseE' l' - = literal concResult - | True - = SBV $ SVal k $ Right $ cache r - where concreteFoldli _ b [] = Just b - concreteFoldli c b (e:es) = case unliteral (op (literal c) (literal b) (literal e)) of - Nothing -> Nothing - Just b' -> concreteFoldli (c+1) b' es - - k = kindOf baseE - r st = do svi <- sbvToSV st baseI - sve <- sbvToSV st baseE - sva <- sbvToSV st l - lam <- lambdaStr st k op - newExpr st k (SBVApp (SeqOp (SeqFoldLeftI lam)) [svi, sve, sva]) + lam <- lambdaStr st HigherOrderArg kb f + let op = SeqOp (SBVFoldl ka kb lam) + registerSpecialFunction st op + newExpr st kb (SBVApp op [svb, svl]) --- | @`foldr` op base s@ folds the sequence from the right. +-- | @`foldr` f base s@ folds the sequence from the right. -- -- >>> foldr (+) 0 [1 .. 5 :: Integer] -- 15 :: SInteger @@ -513,13 +466,25 @@ -- 120 :: SInteger -- >>> foldr (\elt soFar -> soFar ++ singleton elt) ([] :: SList Integer) [1 .. 5 :: Integer] -- [5,4,3,2,1] :: [SInteger] -foldr :: (SymVal a, SymVal b) => (SBV a -> SBV b -> SBV b) -> SBV b -> SList a -> SBV b -foldr op b = foldl (flip op) b . reverse +foldr :: forall a b. (SymVal a, SymVal b) => (SBV a -> SBV b -> SBV b) -> SBV b -> SList a -> SBV b +foldr f base l + | Just l' <- unliteral l, Just base' <- unliteral base, Just concResult <- concreteFoldr base' l' + = literal concResult + | True + = SBV $ SVal kb $ Right $ cache r + where concreteFoldr b [] = Just b + concreteFoldr b (e:es) = case concreteFoldr b es of + Nothing -> Nothing + Just res -> unliteral (literal e `f` literal res) --- | @`foldri` op base i s@ folds the sequence from the right, with the counter given at each element, starting --- at the given value. This function is provided as a parallel to `foldli`. -foldri :: (SymVal a, SymVal b) => (SBV a -> SBV b -> SInteger -> SBV b) -> SBV b -> SInteger -> SList a -> SBV b -foldri op baseE baseI = foldli (\a b i -> op i b a) baseI baseE . reverse + ka = kindOf (Proxy @a) + kb = kindOf (Proxy @b) + r st = do svb <- sbvToSV st base + svl <- sbvToSV st l + lam <- lambdaStr st HigherOrderArg kb f + let op = SeqOp (SBVFoldr ka kb lam) + registerSpecialFunction st op + newExpr st kb (SBVApp op [svb, svl]) -- | @`zip` xs ys@ zips the lists to give a list of pairs. The length of the final list is -- the minumum of the lengths of the given lists. @@ -529,10 +494,22 @@ -- >>> import Data.SBV.Tuple -- >>> foldr (+) 0 (map (\t -> t^._1+t^._2::SInteger) (zip [1..10::Integer] [10, 9..1::Integer])) -- 110 :: SInteger -zip :: (SymVal a, SymVal b) => SList a -> SList b -> SList (a, b) -zip xs ys = map (\t -> tuple (t^._2, ys `elemAt` (t^._1))) - (mapi (curry tuple) 0 (take (length ys) xs)) +zip :: forall a b. (SymVal a, SymVal b) => SList a -> SList b -> SList (a, b) +zip xs ys + | Just xs' <- unliteral xs, Just ys' <- unliteral ys + = literal $ P.zip xs' ys' + | True + = SBV $ SVal kr $ Right $ cache r + where ka = kindOf (Proxy @a) + kb = kindOf (Proxy @b) + kr = KList $ KTuple [ka, kb] + r st = do svxs <- sbvToSV st xs + svys <- sbvToSV st ys + let op = SeqOp (SBVZip ka kb) + registerSpecialFunction st op + newExpr st kr (SBVApp op [svxs, svys]) + -- | @`zipWith` f xs ys@ zips the lists to give a list of pairs, applying the function to each pair of elements. -- The length of the final list is the minumum of the lengths of the given lists. -- @@ -540,20 +517,46 @@ -- [12,14,16,18,20,22,24,26,28,30] :: [SInteger] -- >>> foldr (+) 0 (zipWith (+) [1..10::Integer] [10, 9..1::Integer]) -- 110 :: SInteger -zipWith :: (SymVal a, SymVal b, SymVal c) => (SBV a -> SBV b -> SBV c) -> SList a -> SList b -> SList c -zipWith f xs ys = map (\t -> f (t^._2) (ys `elemAt` (t^._1))) - (mapi (curry tuple) 0 (take (length ys) xs)) +zipWith :: forall a b c. (SymVal a, SymVal b, SymVal c) => (SBV a -> SBV b -> SBV c) -> SList a -> SList b -> SList c +zipWith f xs ys + | Just xs' <- unliteral xs, Just ys' <- unliteral ys, Just concResult <- concreteZipWith xs' ys' + = literal concResult + | True + = SBV $ SVal kr $ Right $ cache r + where concreteZipWith [] _ = Just [] + concreteZipWith _ [] = Just [] + concreteZipWith (a:as) (b:bs) = (:) <$> unliteral (literal a `f` literal b) <*> concreteZipWith as bs + ka = kindOf (Proxy @a) + kb = kindOf (Proxy @b) + kc = kindOf (Proxy @c) + kr = KList kc + + r st = do svxs <- sbvToSV st xs + svys <- sbvToSV st ys + lam <- lambdaStr st HigherOrderArg kc f + let op = SeqOp (SBVZipWith ka kb kc lam) + registerSpecialFunction st op + newExpr st kr (SBVApp op [svxs, svys]) + -- | Concatenate list of lists. -- --- NB. Concat is typically defined in terms of foldr. Here we prefer foldl, since the underlying solver --- primitive is foldl: Otherwise, we'd induce an extra call to reverse. --- -- >>> concat [[1..3::Integer], [4..7], [8..10]] -- [1,2,3,4,5,6,7,8,9,10] :: [SInteger] -concat :: SymVal a => SList [a] -> SList a -concat = foldl (++) [] +concat :: forall a. SymVal a => SList [a] -> SList a +concat l + | Just l' <- unliteral l + = literal (P.concat l') + | True + = SBV $ SVal kla $ Right $ cache r + where ka = kindOf (Proxy @a) + kla = kindOf (Proxy @[a]) + r st = do sva <- sbvToSV st l + let op = SeqOp (SBVConcat ka) + registerSpecialFunction st op + newExpr st kla (SBVApp op [sva]) + -- | Check all elements satisfy the predicate. -- -- >>> let isEven x = x `sMod` 2 .== 0 @@ -561,8 +564,17 @@ -- True -- >>> all isEven [2, 4, 6, 1, 8, 10 :: Integer] -- False -all :: SymVal a => (SBV a -> SBool) -> SList a -> SBool -all f = foldl (\sofar e -> sofar .&& f e) sTrue +all :: forall a. SymVal a => (SBV a -> SBool) -> SList a -> SBool +all f l + | Just l' <- unliteral l + = sAll f (P.map literal l') + | True + = SBV $ SVal KBool $ Right $ cache r + where r st = do sva <- sbvToSV st l + lam <- lambdaStr st HigherOrderArg KBool f + let op = SeqOp (SBVAll (kindOf (Proxy @a)) lam) + registerSpecialFunction st op + newExpr st KBool (SBVApp op [sva]) -- | Check some element satisfies the predicate. -- -- @@ -571,17 +583,48 @@ -- False -- >>> any isEven [2, 4, 6, 1, 8, 10 :: Integer] -- True -any :: SymVal a => (SBV a -> SBool) -> SList a -> SBool -any f = foldl (\sofar e -> sofar .|| f e) sFalse +any :: forall a. SymVal a => (SBV a -> SBool) -> SList a -> SBool +any f l + | Just l' <- unliteral l + = sAny f (P.map literal l') + | True + = SBV $ SVal KBool $ Right $ cache r + where r st = do sva <- sbvToSV st l + lam <- lambdaStr st HigherOrderArg KBool f + let op = SeqOp (SBVAny (kindOf (Proxy @a)) lam) + registerSpecialFunction st op + newExpr st KBool (SBVApp op [sva]) +-- | Conjunction of all the elements. +and :: SList Bool -> SBool +and = all id + +-- | Disjunction of all the elements. +or :: SList Bool -> SBool +or = any id + -- | @filter f xs@ filters the list with the given predicate. -- -- >>> filter (\x -> x `sMod` 2 .== 0) [1 .. 10 :: Integer] -- [2,4,6,8,10] :: [SInteger] -- >>> filter (\x -> x `sMod` 2 ./= 0) [1 .. 10 :: Integer] -- [1,3,5,7,9] :: [SInteger] -filter :: SymVal a => (SBV a -> SBool) -> SList a -> SList a -filter f = foldl (\sofar e -> sofar ++ ite (f e) (singleton e) []) [] +filter :: forall a. SymVal a => (SBV a -> SBool) -> SList a -> SList a +filter f l + | Just l' <- unliteral l, Just concResult <- concreteFilter l' + = literal concResult + | True + = SBV $ SVal k $ Right $ cache r + where concreteFilter l' = case P.map (unliteral . f . literal) l' of + xs | P.any isNothing xs -> Nothing + | True -> Just [e | (True, e) <- P.zip (catMaybes xs) l'] + + k = kindOf (Proxy @(SList a)) + r st = do sva <- sbvToSV st l + lam <- lambdaStr st HigherOrderArg KBool f + let op = SeqOp (SBVFilter (kindOf (Proxy @a)) lam) + registerSpecialFunction st op + newExpr st k (SBVApp op [sva]) -- | Lift a unary operator over lists. lift1 :: forall a b. (SymVal a, SymVal b) => Bool -> SeqOp -> Maybe (a -> b) -> SBV a -> SBV b diff --git a/Data/SBV/Provers/ABC.hs b/Data/SBV/Provers/ABC.hs --- a/Data/SBV/Provers/ABC.hs +++ b/Data/SBV/Provers/ABC.hs @@ -46,7 +46,7 @@ , supportsCustomQueries = False , supportsGlobalDecls = False , supportsDataTypes = False - , supportsFoldAndMap = False + , supportsLambdas = False , supportsSpecialRels = False , supportsDirectAccessors = False , supportsFlattenedModels = Nothing diff --git a/Data/SBV/Provers/Bitwuzla.hs b/Data/SBV/Provers/Bitwuzla.hs --- a/Data/SBV/Provers/Bitwuzla.hs +++ b/Data/SBV/Provers/Bitwuzla.hs @@ -44,7 +44,7 @@ , supportsCustomQueries = True , supportsGlobalDecls = True , supportsDataTypes = False - , supportsFoldAndMap = False + , supportsLambdas = False , supportsSpecialRels = False , supportsDirectAccessors = False , supportsFlattenedModels = Nothing diff --git a/Data/SBV/Provers/Boolector.hs b/Data/SBV/Provers/Boolector.hs --- a/Data/SBV/Provers/Boolector.hs +++ b/Data/SBV/Provers/Boolector.hs @@ -44,7 +44,7 @@ , supportsCustomQueries = True , supportsGlobalDecls = True , supportsDataTypes = False - , supportsFoldAndMap = False + , supportsLambdas = False , supportsSpecialRels = False , supportsDirectAccessors = False , supportsFlattenedModels = Nothing diff --git a/Data/SBV/Provers/CVC4.hs b/Data/SBV/Provers/CVC4.hs --- a/Data/SBV/Provers/CVC4.hs +++ b/Data/SBV/Provers/CVC4.hs @@ -48,7 +48,7 @@ , supportsCustomQueries = True , supportsGlobalDecls = True , supportsDataTypes = True - , supportsFoldAndMap = False + , supportsLambdas = False , supportsSpecialRels = False , supportsDirectAccessors = True , supportsFlattenedModels = Nothing diff --git a/Data/SBV/Provers/CVC5.hs b/Data/SBV/Provers/CVC5.hs --- a/Data/SBV/Provers/CVC5.hs +++ b/Data/SBV/Provers/CVC5.hs @@ -48,7 +48,7 @@ , supportsCustomQueries = True , supportsGlobalDecls = True , supportsDataTypes = True - , supportsFoldAndMap = False + , supportsLambdas = True , supportsSpecialRels = False , supportsDirectAccessors = True , supportsFlattenedModels = Nothing diff --git a/Data/SBV/Provers/DReal.hs b/Data/SBV/Provers/DReal.hs --- a/Data/SBV/Provers/DReal.hs +++ b/Data/SBV/Provers/DReal.hs @@ -48,7 +48,7 @@ , supportsCustomQueries = False , supportsGlobalDecls = False , supportsDataTypes = False - , supportsFoldAndMap = False + , supportsLambdas = False , supportsSpecialRels = False , supportsDirectAccessors = False , supportsFlattenedModels = Nothing diff --git a/Data/SBV/Provers/MathSAT.hs b/Data/SBV/Provers/MathSAT.hs --- a/Data/SBV/Provers/MathSAT.hs +++ b/Data/SBV/Provers/MathSAT.hs @@ -48,7 +48,7 @@ , supportsCustomQueries = True , supportsGlobalDecls = True , supportsDataTypes = True - , supportsFoldAndMap = False + , supportsLambdas = False , supportsSpecialRels = False , supportsDirectAccessors = True , supportsFlattenedModels = Nothing diff --git a/Data/SBV/Provers/OpenSMT.hs b/Data/SBV/Provers/OpenSMT.hs --- a/Data/SBV/Provers/OpenSMT.hs +++ b/Data/SBV/Provers/OpenSMT.hs @@ -44,7 +44,7 @@ , supportsCustomQueries = True , supportsGlobalDecls = True , supportsDataTypes = False - , supportsFoldAndMap = False + , supportsLambdas = False , supportsSpecialRels = False , supportsDirectAccessors = False , supportsFlattenedModels = Nothing diff --git a/Data/SBV/Provers/Prover.hs b/Data/SBV/Provers/Prover.hs --- a/Data/SBV/Provers/Prover.hs +++ b/Data/SBV/Provers/Prover.hs @@ -106,7 +106,12 @@ , solverSetOptions = startOpts , ignoreExitCode = False , redirectVerbose = Nothing - , kdRibbonLength = 40 + , generateHOEquivs = False + , kdOptions = KDOptions { ribbonLength = 40 + , firstifyUniqueLen = 6 + , quiet = False + , measureTime = False + } } -- | If supported, this makes all output go to stdout, which works better with SBV diff --git a/Data/SBV/Provers/Yices.hs b/Data/SBV/Provers/Yices.hs --- a/Data/SBV/Provers/Yices.hs +++ b/Data/SBV/Provers/Yices.hs @@ -46,7 +46,7 @@ , supportsCustomQueries = True , supportsGlobalDecls = True , supportsDataTypes = False - , supportsFoldAndMap = False + , supportsLambdas = False , supportsSpecialRels = False , supportsDirectAccessors = False , supportsFlattenedModels = Nothing diff --git a/Data/SBV/Provers/Z3.hs b/Data/SBV/Provers/Z3.hs --- a/Data/SBV/Provers/Z3.hs +++ b/Data/SBV/Provers/Z3.hs @@ -46,7 +46,7 @@ , supportsCustomQueries = True , supportsGlobalDecls = True , supportsDataTypes = True - , supportsFoldAndMap = True + , supportsLambdas = True , supportsSpecialRels = True , supportsDirectAccessors = False -- Needs ascriptions. (See the CVC4 version of this) , supportsFlattenedModels = Just [ "(set-option :pp.max_depth 4294967295)" diff --git a/Data/SBV/SMT/SMT.hs b/Data/SBV/SMT/SMT.hs --- a/Data/SBV/SMT/SMT.hs +++ b/Data/SBV/SMT/SMT.hs @@ -48,7 +48,7 @@ import Control.DeepSeq (NFData(..)) import Control.Monad (zipWithM, mplus) import Data.Char (isSpace) -import Data.Maybe (fromMaybe, isJust) +import Data.Maybe (isJust) import Data.Int (Int8, Int16, Int32, Int64) import Data.List (intercalate, isPrefixOf, transpose, isInfixOf) import Data.Word (Word8, Word16, Word32, Word64) @@ -58,9 +58,7 @@ import Data.IORef (readIORef, writeIORef) -import Data.Time (getZonedTime, defaultTimeLocale, formatTime, diffUTCTime, getCurrentTime) - -import Data.Either(rights) +import Data.Either (rights) import System.Directory (findExecutable) import System.Environment (getEnv) @@ -70,6 +68,7 @@ import qualified Data.Map.Strict as M import qualified Data.Text as T +import Text.Read (readMaybe) import Data.SBV.Core.AlgReals import Data.SBV.Core.Data @@ -79,12 +78,13 @@ import Data.SBV.Core.SizedFloats(FloatingPoint(..)) -import Data.SBV.SMT.Utils (showTimeoutValue, alignPlain, debug, mergeSExpr, SBVException(..)) +import Data.SBV.SMT.Utils ( showTimeoutValue, alignPlain, debug, mergeSExpr, SBVException(..) + , startTranscript, recordTranscript, finalizeTranscript, recordEndTime, recordException, TranscriptMsg(..) + ) import Data.SBV.Utils.PrettyNum -import Data.SBV.Utils.Lib (joinArgs, splitArgs) -import Data.SBV.Utils.SExpr (parenDeficit) -import Data.SBV.Utils.TDiff (Timing(..), showTDiff) +import Data.SBV.Utils.Lib (joinArgs, splitArgs, needsBars) +import Data.SBV.Utils.SExpr (parenDeficit, nameSupply) import qualified System.Timeout as Timeout (timeout) @@ -603,14 +603,26 @@ [] -> error $ "showModelUI: Unexpected type: " ++ show (SBVType ts) tss -> (init tss, last tss) - sig | isCurried = nm ++ " :: " ++ intercalate " -> " ats ++ " -> " ++ rt - | True = nm ++ " :: (" ++ intercalate ", " ats ++ ") -> " ++ rt + -- signatures require parens if this is a non-ascii name, i.e., needs bars + sigName | needsBars nm = '(' : nm ++ ")" + | True = nm + sig | isCurried = sigName ++ " :: " ++ intercalate " -> " ats ++ " -> " ++ rt + | True = sigName ++ " :: (" ++ intercalate ", " ats ++ ") -> " ++ rt + mkBody (defs, dflt) = map align body where ls = map line defs - defLine = (replicate noOfArgs "_", scv dflt) body = ls ++ [defLine] + -- is the default an argument? This is likely to be z3 specific + defVal = scv dflt + defPos = case span (/= '!') defVal of + (_, '!':n) | Just (i :: Int) <- readMaybe n, i > 0 -> Just (i, nameSupply [] !! (i-1)) -- default is the ith argument + _ -> Nothing -- default is a constant (or something else?) + defLine = case defPos of + Just (i, a) | i > 0 -> (replicate (i - 1) "_" ++ a : replicate (noOfArgs - i) "_", a) + _ -> (replicate noOfArgs "_", defVal) + colWidths = [maximum (0 : map length col) | col <- transpose (map fst body)] resWidth = maximum (0 : map (length . snd) body) @@ -726,7 +738,7 @@ let send :: Maybe Int -> String -> IO () send mbTimeOut command = do hPutStrLn inh (clean command) hFlush inh - recordTranscript (transcript cfg) $ Left (command, mbTimeOut) + recordTranscript (transcript cfg) $ SentMsg command mbTimeOut -- is this a set-command? Then we expect faster response; except for the heartbeat isSetCommand = maybe False chk @@ -758,7 +770,7 @@ getResponseFromSolver mbCommand mbTimeOut = do response <- go True 0 [] let collated = intercalate "\n" $ reverse response - recordTranscript (transcript cfg) $ Right collated + recordTranscript (transcript cfg) $ RecvMsg collated return collated where safeGetLine isFirst h = @@ -1028,80 +1040,6 @@ finalizeTranscript (transcript cfg) ec recordEndTime cfg ctx C.throwIO e) - --- | Compute and report the end time -recordEndTime :: SMTConfig -> State -> IO () -recordEndTime SMTConfig{timing} state = case timing of - NoTiming -> return () - PrintTiming -> do e <- elapsed - putStrLn $ "*** SBV: Elapsed time: " ++ showTDiff e - SaveTiming here -> writeIORef here =<< elapsed - where elapsed = getCurrentTime >>= \end -> return $ diffUTCTime end (startTime state) - --- | Start a transcript file, if requested. -startTranscript :: Maybe FilePath -> SMTConfig -> IO () -startTranscript Nothing _ = return () -startTranscript (Just f) cfg = do ts <- show <$> getZonedTime - mbExecPath <- findExecutable (executable (solver cfg)) - writeFile f $ start ts mbExecPath - where SMTSolver{name, options} = solver cfg - start ts mbPath = unlines [ ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;" - , ";;; SBV: Starting at " ++ ts - , ";;;" - , ";;; Solver : " ++ show name - , ";;; Executable: " ++ fromMaybe "Unable to locate the executable" mbPath - , ";;; Options : " ++ unwords (options cfg ++ extraArgs cfg) - , ";;;" - , ";;; This file is an auto-generated loadable SMT-Lib file." - , ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;" - , "" - ] - --- | Finish up the transcript file. -finalizeTranscript :: Maybe FilePath -> ExitCode -> IO () -finalizeTranscript Nothing _ = return () -finalizeTranscript (Just f) ec = do ts <- show <$> getZonedTime - appendFile f $ end ts - where end ts = unlines [ "" - , ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;" - , ";;;" - , ";;; SBV: Finished at " ++ ts - , ";;;" - , ";;; Exit code: " ++ show ec - , ";;;" - , ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;" - ] - --- If requested, record in the transcript file -recordTranscript :: Maybe FilePath -> Either (String, Maybe Int) String -> IO () -recordTranscript Nothing _ = return () -recordTranscript (Just f) m = do tsPre <- formatTime defaultTimeLocale "; [%T%Q" <$> getZonedTime - let ts = take 15 $ tsPre ++ repeat '0' - case m of - Left (sent, mbTimeOut) -> appendFile f $ unlines $ (ts ++ "] " ++ to mbTimeOut ++ "Sending:") : lines sent - Right recv -> appendFile f $ unlines $ case lines (dropWhile isSpace recv) of - [] -> [ts ++ "] Received: "] -- can't really happen. - [x] -> [ts ++ "] Received: " ++ x] - xs -> (ts ++ "] Received: ") : map ("; " ++) xs - where to Nothing = "" - to (Just i) = "[Timeout: " ++ showTimeoutValue i ++ "] " -{-# INLINE recordTranscript #-} - --- Record the exception -recordException :: Maybe FilePath -> String -> IO () -recordException Nothing _ = return () -recordException (Just f) m = do ts <- show <$> getZonedTime - appendFile f $ exc ts - where exc ts = unlines $ [ "" - , ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;" - , ";;;" - , ";;; SBV: Caught an exception at " ++ ts - , ";;;" - ] - ++ [ ";;; " ++ l | l <- dropWhile null (lines m) ] - ++ [ ";;;" - , ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;" - ] -- We should not be catching/processing asynchronous exceptions. -- See http://github.com/LeventErkok/sbv/issues/410 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 @@ -16,8 +16,12 @@ {-# OPTIONS_GHC -Wall -Werror #-} -module Data.SBV.SMT.SMTLib2(cvt, cvtExp, cvtCV, cvtInc, declUserFuns, constructTables) where +module Data.SBV.SMT.SMTLib2(cvt, cvtExp, cvtCV, cvtInc, declUserFuns, constructTables, setSMTOption) where +import Crypto.Hash.SHA512 (hash) +import qualified Data.ByteString.Base16 as B +import qualified Data.ByteString.Char8 as BC + import Data.Bits (bit) import Data.List (intercalate, partition, nub, elemIndex) import Data.Maybe (listToMaybe, catMaybes) @@ -29,12 +33,12 @@ import qualified Data.Set as Set import Data.SBV.Core.Data -import Data.SBV.Core.Kind (smtType, needsFlattening) +import Data.SBV.Core.Kind (smtType, needsFlattening, expandKinds) import Data.SBV.SMT.Utils import Data.SBV.Control.Types import Data.SBV.Core.Symbolic ( QueryContext(..), SetOp(..), getUserName', getSV, regExpToSMTString - , SMTDef(..), ResultInp(..), ProgInfo(..), SpecialRelOp(..) + , SMTDef(..), ResultInp(..), ProgInfo(..), SpecialRelOp(..), SMTLambda(..) ) import Data.SBV.Utils.PrettyNum (smtRoundingMode, cvToSMTLib) @@ -43,11 +47,40 @@ import qualified Data.Graph as DG +-- | For higher-order functions, we firstify them. This requires a uniqu name creation. Here, +-- we create a firstified name based on the operation. The suffix appended will have at most uniqLen length. +firstify :: Int -> Op -> String +firstify uniqLen o = prefix o ++ "_" ++ take uniqLen (BC.unpack (B.encode (hash (BC.pack (compress (show o)))))) + where prefix (SeqOp SBVReverse {}) = "sbv.reverse" + prefix (SeqOp SBVZip {}) = "sbv.zip" + prefix (SeqOp SBVZipWith {}) = "sbv.zipWith" + prefix (SeqOp SBVMap {}) = "sbv.map" + prefix (SeqOp SBVFoldl {}) = "sbv.foldl" + prefix (SeqOp SBVFoldr {}) = "sbv.foldr" + prefix (SeqOp SBVFilter {}) = "sbv.filter" + prefix (SeqOp SBVAll {}) = "sbv.all" + prefix (SeqOp SBVAny {}) = "sbv.any" + prefix (SeqOp SBVConcat {}) = "sbv.concat" + prefix _ = error $ unlines [ "***" + , "*** Data.SBV.firstify: Didn't expect firstification to be called." + , "***" + , "*** Operator: " ++ show o + , "***" + , "*** Please report this as a bug." + ] + + -- compress and make spaces uniform; get words, and then unwords + compress = unwords . words + -- | Translate a problem into an SMTLib2 script cvt :: SMTLibConverter ([String], [String]) cvt ctx curProgInfo kindInfo isSat comments allInputs (_, consts) tbls uis defs (SBVPgm asgnsSeq) cstrs out cfg = (pgm, exportedDefs) where allKinds = Set.toList kindInfo + -- Below can simply be defined as: nub (sort (G.universeBi asgnsSeq)) + -- Alas, it turns out this is really expensive when we have nested lambdas, so we do an explicit walk + allTopOps = Set.toList $ foldl' (\sofar (_, SBVApp o _) -> Set.insert o sofar) Set.empty asgnsSeq + hasInteger = KUnbounded `Set.member` kindInfo hasArrays = not (null [() | KArray{} <- allKinds]) hasNonBVArrays = not (null [() | KArray k1 k2 <- allKinds, not (isBounded k1 && isBounded k2)]) @@ -56,15 +89,15 @@ || KFloat `Set.member` kindInfo || KDouble `Set.member` kindInfo hasString = KString `Set.member` kindInfo - hasRegExp = (not . null) [() | (_ :: RegExOp) <- G.universeBi asgnsSeq] + hasRegExp = (not . null) [() | (_ :: RegExOp) <- G.universeBi allTopOps] hasChar = KChar `Set.member` kindInfo hasRounding = not $ null [s | (s, _) <- usorts, s == "RoundingMode"] hasBVs = not (null [() | KBounded{} <- allKinds]) usorts = [(s, dt) | KUserSort s dt <- allKinds] trueUSorts = [s | (s, _) <- usorts, s /= "RoundingMode"] tupleArities = findTupleArities kindInfo - hasOverflows = (not . null) [() | (_ :: OvOp) <- G.universeBi asgnsSeq] - hasQuantBools = (not . null) [() | QuantifiedBool{} <- G.universeBi asgnsSeq] + hasOverflows = (not . null) [() | (_ :: OvOp) <- G.universeBi allTopOps] + hasQuantBools = (not . null) [() | QuantifiedBool{} <- G.universeBi allTopOps] hasList = any isList kindInfo hasSets = any isSet kindInfo hasTuples = not . null $ tupleArities @@ -73,21 +106,24 @@ hasRational = any isRational kindInfo rm = roundingMode cfg solverCaps = capabilities (solver cfg) - hasFoldMap = let isFoldMap SeqMap{} = True - isFoldMap SeqMapI{} = True - isFoldMap SeqFoldLeft{} = True - isFoldMap SeqFoldLeftI{} = True - isFoldMap _ = False - in (not . null) [ () | o :: SeqOp <- G.universeBi asgnsSeq, isFoldMap o] + hasLambdas = let needsLambda SBVZipWith{} = True + needsLambda SBVMap{} = True + needsLambda SBVFoldl{} = True + needsLambda SBVFoldr{} = True + needsLambda SBVFilter{} = True + needsLambda SBVAll{} = True + needsLambda SBVAny{} = True + needsLambda _ = False + in (not . null) [() | o :: SeqOp <- G.universeBi allTopOps, needsLambda o] - (needsQuantifiers, needsSpecialRels) = case curProgInfo of - ProgInfo hasQ srs tcs -> (hasQ, not (null srs && null tcs)) + (needsQuantifiers, needsSpecialRels, specialFuncs) = case curProgInfo of + ProgInfo hasQ srs tcs sf -> (hasQ, not (null srs && null tcs), sf) -- Is there a reason why we can't handle this problem? -- NB. There's probably a lot more checking we can do here, but this is a start: doesntHandle = listToMaybe [nope w | (w, have, need) <- checks, need && not (have solverCaps)] where checks = [ ("data types", supportsDataTypes, hasTuples || hasEither || hasMaybe) - , ("folds and maps", supportsFoldAndMap, hasFoldMap) + , ("needs lambdas", supportsLambdas, hasLambdas) , ("set operations", supportsSets, hasSets) , ("bit vectors", supportsBitVectors, hasBVs) , ("special relations", supportsSpecialRels, needsSpecialRels) @@ -102,9 +138,15 @@ , "*** But the chosen solver (" ++ show (name (solver cfg)) ++ ") doesn't support this feature." ] - -- Some cases require all, some require none. Sigh.. - setAll reason = ["(set-logic ALL) ; " ++ reason ++ ", using catch-all."] + -- Some cases require all, some require none. Sigh.. Also, if there're lambdas CVC5 needs HO_ALL + setAll reason = ["(set-logic " ++ allName ++ ") ; " ++ reason ++ ", using catch-all."] + where allName | hasLambdas && isCVC5 = "HO_ALL" + | True = "ALL" + isCVC5 = case name (solver cfg) of + CVC5 -> True + _ -> False + -- Determining the logic is surprisingly tricky! logic -- user told us what to do: so just take it: @@ -138,6 +180,7 @@ | needsSpecialRels = ["; has special relations, no logic set."] -- Things that require ALL + | hasLambdas = setAll "has lambda expressions" | hasInteger = setAll "has unbounded values" | hasRational = setAll "has rational values" | hasReal = setAll "has algebraic reals" @@ -182,7 +225,7 @@ : concat [flattenConfig | any needsFlattening kindInfo, Just flattenConfig <- [supportsFlattenedModels solverCaps]] -- process all other settings we're given. If an option cannot be repeated, we only take the last one. - userSettings = map setSMTOption $ filter (not . isLogic) $ foldr comb [] $ solverSetOptions cfg + userSettings = map (setSMTOption cfg) $ filter (not . isLogic) $ foldr comb [] $ solverSetOptions cfg where -- Logic is already processed, so drop it: isLogic SetLogic{} = True isLogic _ = False @@ -231,8 +274,11 @@ ++ map nonConstTable nonConstTables ++ [ "; --- uninterpreted constants ---" ] ++ concatMap (declUI curProgInfo) uis - ++ [ "; --- SBV Function definitions" | not (null funcMap) ] - ++ concat [ declSBVFunc op nm | (op, nm) <- M.toAscList funcMap ] + ++ [ "; --- Firstified function definitions" | not (null specialFuncs) ] + ++ concat firstifiedDefs + ++ [ "; --- Firstified equivalences" | not (null exportedFirstifiedEqualities) ] + ++ concat exportedFirstifiedEqualities + ++ [ "; -- NB. Skipping firstified equivalences, due to generateHOEquivs setting." | not (null firstifiedEqualities || generateHOEquivs)] ++ [ "; --- user defined functions ---"] ++ userDefs ++ [ "; --- assignments ---" ] @@ -242,7 +288,81 @@ ++ [ "; --- formula ---" ] ++ finalAssert - userDefs = declUserFuns defs + SMTConfig{generateHOEquivs, kdOptions = KDOptions{firstifyUniqueLen}} = cfg + + (firstifiedDefs, firstifiedFuncs) + = case dup res of + Nothing -> ([def | (_, (_, def)) <- res], [(op, nm) | (op, (nm, _)) <- res]) + Just (o, o', n) -> error $ unlines [ "" + , "*** Data.SBV: Insufficient unique length in firstification." + , "***" + , "*** Operator 1 : " ++ show o + , "*** Operator 2 : " ++ show o' + , "*** Mapped name: " ++ n + , "*** Unique len : " ++ show firstifyUniqueLen + , "***" + , "*** Such collisions should be rare, but looks like you ran into one!" + , "*** Try running with an increased unique-length:" + , "***" + , "*** solver{firstifyUniqueLen = N}" + , "***" + , "*** where N is larger than " ++ show firstifyUniqueLen + , "***" + , "*** For instance:" + , "***" + , "*** satWith z3{firstUniqueLen = " ++ show (firstifyUniqueLen + 1) ++ "}" + , "***" + , "*** If that doesn't resolve the problem, or if you believe this is caused by some" + , "*** other problem, please report his as a bug." + ] + where res = [(op, declSBVFunc cfg op) | op <- reverse specialFuncs] + dup [] = Nothing + dup ((o, (n, _)): xs) = case [o' | (o', (n', _)) <- xs, n == n'] of + [] -> dup xs + (o' : _) -> Just (o, o', n) + + exportedFirstifiedEqualities + | generateHOEquivs + = firstifiedEqualities + | True + = [] + + firstifiedEqualities = map equate $ combs firstifiedFuncs + where combs :: [(Op, String)] -> [(Op, (String, SMTLambda), (String, SMTLambda))] + combs [] = [] + combs ((o1, nm1):fs) = [(o1, (nm1, l1), (nm2, l2)) | (o2, nm2) <- fs, Just (l1, l2) <- [getFuncs o1 o2]] ++ combs fs + + -- same if the same op sans the lambda + getFuncs :: Op -> Op -> Maybe (SMTLambda, SMTLambda) + getFuncs (SeqOp (SBVZipWith a b c f)) (SeqOp (SBVZipWith x y z g)) | [a, b, c] == [x, y, z] = Just (f, g) + getFuncs (SeqOp (SBVMap a b f)) (SeqOp (SBVMap x y g)) | [a, b ] == [x, y ] = Just (f, g) + getFuncs (SeqOp (SBVFoldl a b f)) (SeqOp (SBVFoldl x y g)) | [a, b ] == [x, y ] = Just (f, g) + getFuncs (SeqOp (SBVFoldr a b f)) (SeqOp (SBVFoldr x y g)) | [a, b ] == [x, y ] = Just (f, g) + getFuncs (SeqOp (SBVFilter a f)) (SeqOp (SBVFilter x g)) | [a ] == [x ] = Just (f, g) + getFuncs (SeqOp (SBVAll a f)) (SeqOp (SBVAll x g)) | [a ] == [x ] = Just (f, g) + getFuncs (SeqOp (SBVAny a f)) (SeqOp (SBVAny x g)) | [a ] == [x ] = Just (f, g) + getFuncs _ _ = Nothing + + equate :: (Op, (String, SMTLambda), (String, SMTLambda)) -> [String] + equate (o, (nm1, f), (nm2, g)) = [ "; Equality for " ++ nm1 ++ " vs. " ++ nm2 + , "(assert (forall (" ++ decls ++ ")" + , " (=> (= " ++ show f ++ " " ++ show g ++ ")" + , " (= (" ++ nm1 ++ " " ++ args ++ ") (" ++ nm2 ++ " " ++ args ++ ")))))" + ] + where params = paramsOf o + args = unwords $ map fst params + decls = unwords ['(' : n ++ " " ++ smtType k ++ ")" | (n, k) <- params] + + paramsOf (SeqOp (SBVZipWith k1 k2 _ _)) = [ ("xs", KList k1), ("ys", KList k2)] + paramsOf (SeqOp (SBVMap k1 _ _)) = [ ("xs", KList k1)] + paramsOf (SeqOp (SBVFoldl k1 k2 _)) = [("b", k2), ("xs", KList k1)] + paramsOf (SeqOp (SBVFoldr k1 k2 _)) = [("b", k2), ("xs", KList k1)] + paramsOf (SeqOp (SBVFilter k1 _)) = [ ("xs", KList k1)] + paramsOf (SeqOp (SBVAll k1 _)) = [ ("xs", KList k1)] + paramsOf (SeqOp (SBVAny k1 _)) = [ ("xs", KList k1)] + paramsOf op = error $ "Data.SBV.firstifiedEqualities: Unexpected op: " ++ show op + + userDefs = declUserFuns defs exportedDefs | null userDefs = ["; No calls to 'smtFunction' found."] @@ -289,10 +409,6 @@ | s == falseSV = Just $ Left falseSV | True = Just $ Left s - -- SBV only functions. - funcMap = M.fromList [(op, "|sbv.reverse_" ++ show k ++ "|") | (op, k) <- revs] - where revs = nub [(op, k) | op@(SeqOp (SBVReverse k)) <- G.universeBi asgnsSeq] - asgns = F.toList asgnsSeq userNameMap = M.fromList $ map (\nSymVar -> (getSV nSymVar, getUserName' nSymVar)) inputs @@ -301,12 +417,66 @@ _ -> Nothing -- Declare "known" SBV functions here -declSBVFunc :: Op -> String -> [String] -declSBVFunc op nm = case op of - SeqOp (SBVReverse KString) -> mkStringRev - SeqOp (SBVReverse (KList k)) -> mkSeqRev (KList k) - _ -> error $ "Data.SBV.declSBVFunc: Unexpected internal function: " ++ show (op, nm) - where mkStringRev = [ "(define-fun-rec " ++ nm ++ " ((str String)) String" +declSBVFunc :: SMTConfig -> Op -> (String, [String]) +declSBVFunc cfg op = (nm, comment ++ body) + where nm = firstify (firstifyUniqueLen (kdOptions cfg)) op + + comment = ["; Firstified function: " ++ htyp] + + body = case op of + SeqOp (SBVReverse KString) -> mkStringRev + SeqOp (SBVReverse (KList k)) -> mkSeqRev (KList k) + SeqOp (SBVZip k1 k2) -> mkZip k1 k2 Nothing + SeqOp (SBVZipWith k1 k2 k3 (SMTLambda f)) -> mkZip k1 k2 (Just (k3, f)) + SeqOp (SBVMap k1 k2 (SMTLambda f)) -> mkMap k1 k2 f + SeqOp (SBVFoldl k1 k2 (SMTLambda f)) -> mkFoldl k1 k2 f + SeqOp (SBVFoldr k1 k2 (SMTLambda f)) -> mkFoldr k1 k2 f + SeqOp (SBVFilter ek (SMTLambda f)) -> mkFilter ek f + SeqOp (SBVAll ek (SMTLambda f)) -> mkAnyAll True ek f + SeqOp (SBVAny ek (SMTLambda f)) -> mkAnyAll False ek f + SeqOp (SBVConcat ek) -> mkConcat ek + _ -> error $ "Data.SBV.declSBVFunc.body: Unexpected internal function: " + ++ show (op, nm) + + shf :: String -> [Kind] -> Kind -> String + shf f args rt = f ++ " :: " ++ intercalate " -> " (map show (args ++ [rt])) + + shh :: String -> ([Kind], Kind) -> ([Kind], Kind) -> String + shh f (fargs, fret) (args, rt) = f ++ " :: (" ++ intercalate " -> " (map show (fargs ++ [fret])) ++ ") -> " + ++ intercalate " -> " (map show (args ++ [rt])) + + htyp = case op of + SeqOp (SBVReverse KString) -> shf "reverse" [KString] KString + SeqOp (SBVReverse k@KList{}) -> shf "reverse" [k] k + SeqOp (SBVZip a b) -> shf "zip" [KList a, KList b] (KList (KTuple [a, b])) + SeqOp (SBVZipWith a b c _) -> shh "zipWith" ([a, b], c) ([KList a, KList b], KList c) + SeqOp (SBVMap a b _) -> shh "map" ([a], b) ([KList a], KList b) + SeqOp (SBVFoldl a b _) -> shh "foldl" ([b, a], b) ([b, KList a], b) + SeqOp (SBVFoldr a b _) -> shh "foldr" ([a, b], b) ([b, KList a], b) + SeqOp (SBVFilter a _) -> shh "filter" ([a], KBool) ([KList a], KList a) + SeqOp (SBVAll a _) -> shh "all" ([a], KBool) ([KList a], KBool) + SeqOp (SBVAny a _) -> shh "any" ([a], KBool) ([KList a], KBool) + SeqOp (SBVConcat a) -> shf "concat" [KList (KList a)] (KList a) + _ -> error $ "Data.SBV.declSBVFunc.htyp: Unexpected internal function: " ++ show (op, nm) + + -- in Z3, lambdas are applied with select. In CVC5, it's @. This might change with higher-order features being added to SMTLib in v3 + par x = "(" ++ x ++ ")" + app f args = par $ unwords $ f : args + + happ f args | isCVC5 = app "@" (f : args) + | True = app "select" (f : args) + + hd l = app "seq.nth" [l, "0"] + tl l = app "seq.extract" [l, "1", app "-" [app "seq.len" [l], "1"]] + + empty typ = app "as seq.empty" [typ] + isEmpty arg typ = app "=" [arg, empty typ] + + isCVC5 = case name (solver cfg) of + CVC5 -> True + _ -> False + + mkStringRev = [ "(define-fun-rec " ++ nm ++ " ((str String)) String" , " (ite (= str \"\")" , " \"\"" , " (str.++ (" ++ nm ++ " (str.substr str 1 (- (str.len str) 1)))" @@ -315,19 +485,95 @@ mkSeqRev k = [ "(define-fun-rec " ++ nm ++ " ((lst " ++ t ++ ")) " ++ t - , " (ite (= lst (as seq.empty " ++ t ++ "))" - , " (as seq.empty " ++ t ++ ")" - , " (seq.++ (" ++ nm ++ " (seq.extract lst 1 (- (seq.len lst) 1))) (seq.unit (seq.nth lst 0)))))" + , " (ite " ++ isEmpty "lst" t + , " " ++ empty t + , " (seq.++ " ++ app nm [tl "lst"] ++ " (seq.unit " ++ hd "lst" ++ "))))" ] where t = smtType k + -- [a] -> [b] -> [(a, b)] + -- [a] -> [b] -> (a -> b -> c) -> [c] + mkZip a b mbcF = [ "(define-fun-rec " ++ nm ++ " ((lst1 " ++ tla ++ ") (lst2 " ++ tlb ++ ")) " ++ tlr + , " (ite " ++ app "or" [isEmpty "lst1" tla, isEmpty "lst2" tlb] + , " " ++ empty tlr + , " (seq.++ (seq.unit " ++ mkTup (hd "lst1") (hd "lst2") ++ ") " ++ app nm [tl "lst1", tl "lst2"] ++ ")))" + ] + where tla = smtType (KList a) + tlb = smtType (KList b) + tlr = case mbcF of + Nothing -> smtType (KList (KTuple [a, b])) + Just (c, _) -> smtType (KList c) + + mkTup x y = case mbcF of + Just (_, f) -> happ f [x, y] + Nothing -> app tup [x, y] + tup = app "as" ["mkSBVTuple2", app "SBVTuple2" [smtType a, smtType b]] + + -- (b -> a -> b) -> b -> [a] -> b + mkFoldl a b f = [ "(define-fun-rec " ++ nm ++ " ((base " ++ tb ++ ") (lst " ++ tla ++ ")) " ++ tb + , " (ite " ++ isEmpty "lst" tla + , " base" + , " " ++ app nm [happ f ["base", hd "lst"], tl "lst"] ++ "))" + ] + where tla = smtType (KList a) + tb = smtType b + + -- (a -> b -> b) -> b -> [a] -> b + mkFoldr a b f = [ "(define-fun-rec " ++ nm ++ " ((base " ++ tb ++ ") (lst " ++ tla ++ ")) " ++ tb + , " (ite " ++ isEmpty "lst" tla + , " base" + , " " ++ happ f [hd "lst", app nm ["base", tl "lst"]] ++ "))" + ] + where tla = smtType (KList a) + tb = smtType b + + -- (a -> b) -> [a] -> [b] + mkMap a b f = [ "(define-fun-rec " ++ nm ++ " ((lst " ++ tla ++ ")) " ++ tlb + , " (ite " ++ isEmpty "lst" tla + , " " ++ empty tlb + , " (seq.++ (seq.unit " ++ happ f [hd "lst"] ++ ")" + , " " ++ app nm [tl "lst"] ++ ")))" + ] + where tla = smtType (KList a) + tlb = smtType (KList b) + + -- (a -> Bool) -> [a] -> [a] + mkFilter a f = [ "(define-fun-rec " ++ nm ++ " ((lst " ++ tla ++ ")) " ++ tla + , " (ite " ++ isEmpty "lst" tla + , " " ++ empty tla + , " (let ((rest (" ++ nm ++ " " ++ tl "lst" ++ ")))" + , " (ite " ++ happ f [hd "lst"] + , " (seq.++ (seq.unit " ++ hd "lst" ++ ") rest)" + , " rest))))" + ] + where tla = smtType (KList a) + + -- (a -> Bool) -> [a] -> Bool + mkAnyAll isAll a f = [ "(define-fun-rec " ++ nm ++ " ((lst " ++ tla ++ ")) Bool" + , " (ite " ++ isEmpty "lst" tla + , " " ++ base + , " " ++ app conn [happ f [hd "lst"], app nm [tl "lst"]] ++ "))" + ] + where tla = smtType (KList a) + (base, conn) | isAll = ("true", "and") + | True = ("false", "or") + + -- [[a]] -> [a] + mkConcat a = [ "(define-fun-rec " ++ nm ++ " ((lst " ++ tlla ++ ")) " ++ tla + , " (ite " ++ isEmpty "lst" tlla + , " " ++ empty tla + , " (seq.++ " ++ hd "lst" ++ " (" ++ nm ++ " " ++ tl "lst" ++ "))))" + ] + where tla = smtType (KList a) + tlla = smtType (KList (KList a)) + -- | Declare new sorts declSort :: (String, Maybe [String]) -> [String] declSort (s, _) | s == "RoundingMode" -- built-in-sort; so don't declare. = [] declSort (s, Nothing) = [ "(declare-sort " ++ s ++ " 0) ; N.B. Uninterpreted sort." - , "(declare-fun " ++ s ++ "_witness () " ++ s ++ ")" + , "(declare-fun " ++ witnessName s ++ " () " ++ s ++ ")" ] declSort (s, Just fs) = [ "(declare-datatypes ((" ++ s ++ " 0)) ((" ++ unwords (map (\c -> "(" ++ c ++ ")") fs) ++ ")))" , "(define-fun " ++ s ++ "_constrIndex ((x " ++ s ++ ")) Int" @@ -472,7 +718,7 @@ -- table declarations ++ tableDecls -- expressions - ++ concatMap (declDef curProgInfo cfg tableMap) (F.toList asgnsSeq) + ++ concatMap (declDef curProgInfo cfg tableMap) asgnsSeq -- table setups ++ concat tableAssigns -- extra constraints @@ -499,8 +745,8 @@ declDef :: ProgInfo -> SMTConfig -> TableMap -> (SV, SBVExpr) -> [String] declDef curProgInfo cfg tableMap (s, expr) = case expr of - SBVApp (Label m) [e] -> defineFun cfg (s, cvtSV e) (Just m) - e -> defineFun cfg (s, cvtExp curProgInfo caps rm tableMap e) Nothing + SBVApp (Label m) [e] -> defineFun cfg (s, cvtSV e) (Just m) + e -> defineFun cfg (s, cvtExp cfg curProgInfo caps rm tableMap e) Nothing where caps = capabilities (solver cfg) rm = roundingMode cfg @@ -562,11 +808,11 @@ where mkNode d = (d, getKey d, getDeps d) getKey (d, _) = case d of - SMTDef n _ _ _ _ _ -> n - SMTLam{} -> error $ "Data.SBV.declFuns: Unexpected definition kind: " ++ show d + SMTDef n _ _ _ _ -> n + SMTLam{} -> error $ "Data.SBV.declFuns: Unexpected definition kind: " ++ show d - getDeps (SMTDef _ _ d _ _ _, _) = d - getDeps (l@SMTLam{}, t) = error $ "Data.SBV.declFuns: Unexpected definition: " ++ show (l, t) + getDeps (SMTDef _ _ d _ _, _) = d + getDeps (l@SMTLam{}, t) = error $ "Data.SBV.declFuns: Unexpected definition: " ++ show (l, t) mkDecl Nothing rt = "() " ++ rt mkDecl (Just p) rt = p ++ " " ++ rt @@ -580,7 +826,7 @@ xs -> declUserDefMulti xs declUserDef _ d@(SMTLam{}, _) = error $ "Data.SBV.declFuns: Unexpected anonymous lambda in user-defined functions: " ++ show d - declUserDef isRec (SMTDef nm fk deps _ops param body, ty) = ("; " ++ nm ++ " :: " ++ show ty ++ recursive ++ frees ++ "\n") ++ s + declUserDef isRec (SMTDef nm fk deps param body, ty) = ("; " ++ nm ++ " :: " ++ show ty ++ recursive ++ frees ++ "\n") ++ s where (recursive, definer) | isRec = (" [Recursive]", "define-fun-rec") | True = ("", "define-fun") @@ -595,7 +841,7 @@ -- declare a bunch of mutually-recursive functions declUserDefMulti bs = render $ map collect bs where collect d@(SMTLam{}, _) = error $ "Data.SBV.declFuns: Unexpected lambda in user-defined mutual-recursion group: " ++ show d - collect (SMTDef nm fk deps _ops param body, ty) = (deps, nm, ty, '(' : nm ++ " " ++ decl ++ ")", body 3) + collect (SMTDef nm fk deps param body, ty) = (deps, nm, ty, '(' : nm ++ " " ++ decl ++ ")", body 3) where decl = mkDecl param (smtType fk) render defs = intercalate "\n" $ @@ -684,7 +930,7 @@ cvtType (SBVType xs) = "(" ++ unwords (map smtType body) ++ ") " ++ smtType ret where (body, ret) = (init xs, last xs) -type TableMap = IM.IntMap String +type TableMap = IM.IntMap String -- Present an SV, simply show cvtSV :: SV -> String @@ -698,8 +944,8 @@ | Just tn <- i `IM.lookup` m = tn | True = "table" ++ show i -- constant tables are always named this way -cvtExp :: ProgInfo -> SolverCapabilities -> RoundingMode -> TableMap -> SBVExpr -> String -cvtExp curProgInfo caps rm tableMap expr@(SBVApp _ arguments) = sh expr +cvtExp :: SMTConfig -> ProgInfo -> SolverCapabilities -> RoundingMode -> TableMap -> SBVExpr -> String +cvtExp cfg curProgInfo caps rm tableMap expr@(SBVApp _ arguments) = sh expr where hasPB = supportsPseudoBooleans caps hasInt2bv = supportsInt2bv caps hasDistinct = supportsDistinct caps @@ -829,6 +1075,8 @@ ps = " (" ++ unwords (map smtType params) ++ ") " aResult = "(_ is (" ++ fld ++ ps ++ smtType res ++ "))" + firstifiedName = firstify (firstifyUniqueLen (kdOptions cfg)) + sh (SBVApp Ite [a, b, c]) = "(ite " ++ cvtSV a ++ " " ++ cvtSV b ++ " " ++ cvtSV c ++ ")" sh (SBVApp (LkUp (t, aKnd, _, l) i e) []) @@ -884,15 +1132,15 @@ sh (SBVApp (KindCast f t) [a]) = handleKindCast hasInt2bv f t (cvtSV a) - sh (SBVApp (ArrayLambda s) []) = s + sh (SBVApp (ArrayLambda s) []) = show s sh (SBVApp ReadArray [a, i]) = "(select " ++ cvtSV a ++ " " ++ cvtSV i ++ ")" sh (SBVApp WriteArray [a, i, e]) = "(store " ++ cvtSV a ++ " " ++ cvtSV i ++ " " ++ cvtSV e ++ ")" sh (SBVApp (Uninterpreted nm) []) = nm sh (SBVApp (Uninterpreted nm) args) = "(" ++ nm ++ " " ++ unwords (map cvtSV args) ++ ")" - sh (SBVApp (QuantifiedBool _ i) []) = i - sh (SBVApp (QuantifiedBool _ i) args) = error $ "SBV.SMT.SMTLib2.cvtExp: unexpected arguments to quantified boolean: " ++ show (i, args) + sh (SBVApp (QuantifiedBool i) []) = i + sh (SBVApp (QuantifiedBool i) args) = error $ "SBV.SMT.SMTLib2.cvtExp: unexpected arguments to quantified boolean: " ++ show (i, args) sh a@(SBVApp (SpecialRelOp k o) args) | not (null args) @@ -974,8 +1222,18 @@ sh (SBVApp (RegExOp o@RegExEq{}) []) = show o sh (SBVApp (RegExOp o@RegExNEq{}) []) = show o - -- Reverse is special, since we need to generate call to the internally generated function - sh (SBVApp (SeqOp (SBVReverse k)) args) = "(|sbv.reverse_" ++ show k ++ "| " ++ unwords (map cvtSV args) ++ ")" + -- Reverse and higher order functions are special + sh (SBVApp o@(SeqOp SBVReverse{}) args) = "(" ++ firstifiedName o ++ " " ++ unwords (map cvtSV args) ++ ")" + sh (SBVApp o@(SeqOp SBVZip{}) args) = "(" ++ firstifiedName o ++ " " ++ unwords (map cvtSV args) ++ ")" + sh (SBVApp o@(SeqOp SBVZipWith{}) args) = "(" ++ firstifiedName o ++ " " ++ unwords (map cvtSV args) ++ ")" + sh (SBVApp o@(SeqOp SBVReverse{}) args) = "(" ++ firstifiedName o ++ " " ++ unwords (map cvtSV args) ++ ")" + sh (SBVApp o@(SeqOp SBVMap{}) args) = "(" ++ firstifiedName o ++ " " ++ unwords (map cvtSV args) ++ ")" + sh (SBVApp o@(SeqOp SBVFoldl{}) args) = "(" ++ firstifiedName o ++ " " ++ unwords (map cvtSV args) ++ ")" + sh (SBVApp o@(SeqOp SBVFoldr{}) args) = "(" ++ firstifiedName o ++ " " ++ unwords (map cvtSV args) ++ ")" + sh (SBVApp o@(SeqOp SBVFilter{}) args) = "(" ++ firstifiedName o ++ " " ++ unwords (map cvtSV args) ++ ")" + sh (SBVApp o@(SeqOp SBVAll{} ) args) = "(" ++ firstifiedName o ++ " " ++ unwords (map cvtSV args) ++ ")" + sh (SBVApp o@(SeqOp SBVAny{} ) args) = "(" ++ firstifiedName o ++ " " ++ unwords (map cvtSV args) ++ ")" + sh (SBVApp o@(SeqOp SBVConcat{}) args) = "(" ++ firstifiedName o ++ " " ++ unwords (map cvtSV args) ++ ")" sh (SBVApp (SeqOp op) args) = "(" ++ show op ++ " " ++ unwords (map cvtSV args) ++ ")" @@ -1164,7 +1422,11 @@ _ -> (init inputKS, last inputKS) -- Does the kind KChar and KRational *not* occur in the kind anywhere? - charRatFree k = null $ [() | KChar <- G.universe k] ++ [() | KRational <- G.universe k] + charRatFree k = all notCharOrRat (expandKinds k) + where notCharOrRat KChar = False + notCharOrRat KRational = False + notCharOrRat _ = True + noCharOrRat = charRatFree result needsQuant = not $ null args @@ -1399,3 +1661,40 @@ where addIf :: [Int] -> String addIf cs = "(+ " ++ unwords ["(ite " ++ a ++ " " ++ show c ++ " 0)" | (a, c) <- zip args cs] ++ ")" + +-- | Translate an option setting to SMTLib. Note the SetLogic/SetInfo discrepancy. +setSMTOption :: SMTConfig -> SMTOption -> String +setSMTOption cfg = set + where set (DiagnosticOutputChannel f) = opt [":diagnostic-output-channel", show f] + set (ProduceAssertions b) = opt [":produce-assertions", smtBool b] + set (ProduceAssignments b) = opt [":produce-assignments", smtBool b] + set (ProduceProofs b) = opt [":produce-proofs", smtBool b] + set (ProduceInterpolants b) = opt [":produce-interpolants", smtBool b] + set (ProduceUnsatAssumptions b) = opt [":produce-unsat-assumptions", smtBool b] + set (ProduceUnsatCores b) = opt [":produce-unsat-cores", smtBool b] + set (ProduceAbducts b) = opt [":produce-abducts", smtBool b] + set (RandomSeed i) = opt [":random-seed", show i] + set (ReproducibleResourceLimit i) = opt [":reproducible-resource-limit", show i] + set (SMTVerbosity i) = opt [":verbosity", show i] + set (OptionKeyword k as) = opt (k : as) + set (SetLogic l) = logic l + set (SetInfo k as) = info (k : as) + set (SetTimeOut i) = opt $ timeOut i + + opt xs = "(set-option " ++ unwords xs ++ ")" + info xs = "(set-info " ++ unwords xs ++ ")" + + logic Logic_NONE = "; NB. not setting the logic per user request of Logic_NONE" + logic l = "(set-logic " ++ show l ++ ")" + + -- timeout is not standard. We distinguish between CVC/Z3. All else follows z3 + -- The value is in milliseconds, which is how z3/CVC interpret it + timeOut i = case name (solver cfg) of + CVC4 -> [":tlimit-per", show i] + CVC5 -> [":tlimit-per", show i] + _ -> [":timeout", show i] + + -- SMTLib's True/False is spelled differently than Haskell's. + smtBool :: Bool -> String + smtBool True = "true" + smtBool False = "false" diff --git a/Data/SBV/SMT/SMTLibNames.hs b/Data/SBV/SMT/SMTLibNames.hs --- a/Data/SBV/SMT/SMTLibNames.hs +++ b/Data/SBV/SMT/SMTLibNames.hs @@ -11,11 +11,11 @@ {-# OPTIONS_GHC -Wall -Werror #-} -module Data.SBV.SMT.SMTLibNames where +module Data.SBV.SMT.SMTLibNames (isReserved) where import Data.Char (toLower) --- | Names reserved by SMTLib. This list is current as of Dec 6 2015; but of course +-- | Names reserved by SMTLib, all lower-case. This list is current as of Dec 6 2015; but of course -- there's no guarantee it'll stay that way. smtLibReservedNames :: [String] smtLibReservedNames = map (map toLower) @@ -28,3 +28,7 @@ -- The following are most likely Z3 specific , "interval", "assert-soft" ] + +-- | Is this name reserved? Note that we'll ignore case in checking here. This is probably over-cautious. +isReserved :: String -> Bool +isReserved = (`elem` smtLibReservedNames) diff --git a/Data/SBV/SMT/Utils.hs b/Data/SBV/SMT/Utils.hs --- a/Data/SBV/SMT/Utils.hs +++ b/Data/SBV/SMT/Utils.hs @@ -16,6 +16,7 @@ module Data.SBV.SMT.Utils ( SMTLibConverter , SMTLibIncConverter + , witnessName , addAnnotations , showTimeoutValue , alignDiagnostic @@ -23,22 +24,38 @@ , debug , mergeSExpr , SBVException(..) + , startTranscript + , finalizeTranscript + , recordTranscript + , recordException + , recordEndTime + , TranscriptMsg(..) ) where import qualified Control.Exception as C +import Control.Monad (zipWithM_) import Control.Monad.Trans (MonadIO, liftIO) import Data.SBV.Core.Data -import Data.SBV.Core.Symbolic (QueryContext, CnstMap, SMTDef, ResultInp(..), ProgInfo(..)) -import Data.SBV.Utils.Lib (joinArgs) +import Data.SBV.Core.Symbolic (QueryContext, CnstMap, SMTDef, ResultInp(..), ProgInfo(..), startTime) -import Data.List (intercalate) +import Data.SBV.Utils.Lib (joinArgs) +import Data.SBV.Utils.TDiff (Timing(..), showTDiff) + +import Data.IORef (writeIORef) +import Data.Time (getZonedTime, defaultTimeLocale, formatTime, diffUTCTime, getCurrentTime) + +import Data.Char (isSpace) +import Data.Maybe (fromMaybe) +import Data.List (intercalate) + import qualified Data.Set as Set (Set) import qualified Data.Sequence as S (Seq) -import System.Exit (ExitCode(..)) +import System.Directory (findExecutable) +import System.Exit (ExitCode(..)) -- | An instance of SMT-Lib converter; instantiated for SMT-Lib v1 and v2. (And potentially for newer versions in the future.) type SMTLibConverter a = QueryContext -- ^ Internal or external query? @@ -69,6 +86,11 @@ -> SMTConfig -- ^ configuration -> a +-- | The name of a witness for a type. We should make sure this doesn't conflict any reserved names, but I think the chances of that is +-- pretty low anyhow. +witnessName :: String -> String +witnessName = (++ "_witness") + -- | Create an annotated term addAnnotations :: [(String, String)] -> String -> String addAnnotations [] x = x @@ -120,6 +142,7 @@ go i (')':cs) = let i'= i-1 in i' `seq` go i' cs go i ('"':cs) = go i (skipString cs) go i ('|':cs) = go i (skipBar cs) + go i (';':cs) = go i (drop 1 (dropWhile (/= '\n') cs)) go i (_ :cs) = go i cs grab i ls @@ -195,3 +218,85 @@ rest -> g ++ ["***"] ++ rest in unlines $ join [grp1, grp2, grp3, grp4] + +-- | Compute and report the end time +recordEndTime :: SMTConfig -> State -> IO () +recordEndTime SMTConfig{timing} state = case timing of + NoTiming -> return () + PrintTiming -> do e <- elapsed + putStrLn $ "*** SBV: Elapsed time: " ++ showTDiff e + SaveTiming here -> writeIORef here =<< elapsed + where elapsed = getCurrentTime >>= \end -> return $ diffUTCTime end (startTime state) + +-- | Start a transcript file, if requested. +startTranscript :: Maybe FilePath -> SMTConfig -> IO () +startTranscript Nothing _ = return () +startTranscript (Just f) cfg = do ts <- show <$> getZonedTime + mbExecPath <- findExecutable (executable (solver cfg)) + writeFile f $ start ts mbExecPath + where SMTSolver{name, options} = solver cfg + start ts mbPath = unlines [ ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;" + , ";;; SBV: Starting at " ++ ts + , ";;;" + , ";;; Solver : " ++ show name + , ";;; Executable: " ++ fromMaybe "Unable to locate the executable" mbPath + , ";;; Options : " ++ unwords (options cfg ++ extraArgs cfg) + , ";;;" + , ";;; This file is an auto-generated loadable SMT-Lib file." + , ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;" + , "" + ] + +-- | Finish up the transcript file. +finalizeTranscript :: Maybe FilePath -> ExitCode -> IO () +finalizeTranscript Nothing _ = return () +finalizeTranscript (Just f) ec = do ts <- show <$> getZonedTime + appendFile f $ end ts + where end ts = unlines [ "" + , ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;" + , ";;;" + , ";;; SBV: Finished at " ++ ts + , ";;;" + , ";;; Exit code: " ++ show ec + , ";;;" + , ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;" + ] + +-- Kind of things we can record +data TranscriptMsg = SentMsg String (Maybe Int) -- ^ Message sent, and time-out if any + | RecvMsg String -- ^ Message received + | DebugMsg String -- ^ A debug message; neither sent nor received + +-- If requested, record in the transcript file +recordTranscript :: Maybe FilePath -> TranscriptMsg -> IO () +recordTranscript Nothing _ = return () +recordTranscript (Just f) m = do tsPre <- formatTime defaultTimeLocale "; [%T%Q" <$> getZonedTime + let ts = take 15 $ tsPre ++ repeat '0' + case m of + SentMsg sent mbTimeOut -> appendFile f $ unlines $ (ts ++ "] " ++ to mbTimeOut ++ "Sending:") : lines sent + RecvMsg recv -> appendFile f $ unlines $ case lines (dropWhile isSpace recv) of + [] -> [ts ++ "] Received: "] -- can't really happen. + [x] -> [ts ++ "] Received: " ++ x] + xs -> (ts ++ "] Received: ") : map ("; " ++) xs + DebugMsg msg -> let tag = ts ++ "] " + emp = ';' : drop 1 (map (const ' ') tag) + in zipWithM_ (\t l -> appendFile f (t ++ l ++ "\n")) (tag : repeat emp) (lines msg) + where to Nothing = "" + to (Just i) = "[Timeout: " ++ showTimeoutValue i ++ "] " +{-# INLINE recordTranscript #-} + +-- Record the exception +recordException :: Maybe FilePath -> String -> IO () +recordException Nothing _ = return () +recordException (Just f) m = do ts <- show <$> getZonedTime + appendFile f $ exc ts + where exc ts = unlines $ [ "" + , ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;" + , ";;;" + , ";;; SBV: Caught an exception at " ++ ts + , ";;;" + ] + ++ [ ";;; " ++ l | l <- dropWhile null (lines m) ] + ++ [ ";;;" + , ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;" + ] diff --git a/Data/SBV/Set.hs b/Data/SBV/Set.hs --- a/Data/SBV/Set.hs +++ b/Data/SBV/Set.hs @@ -56,8 +56,6 @@ import Data.SBV.Core.Kind -import qualified Data.Generics.Uniplate.Data as G - -- $setup -- >>> -- For doctest purposes only: -- >>> import Prelude hiding(null) @@ -115,7 +113,7 @@ -- Q.E.D. complement :: forall a. (Ord a, SymVal a) => SSet a -> SSet a complement ss - | KChar `elem` G.universe k + | KChar `elem` expandKinds k = error $ unlines [ "*** Data.SBV: Set.complement is not available for the type " ++ show k , "***" , "*** See: https://github.com/LeventErkok/sbv/issues/601 for a discussion" @@ -253,8 +251,8 @@ -- -- >>> prove $ \x -> x `notMember` observe "set" (singleton (x :: SInteger)) -- Falsifiable. Counter-example: --- set = {0} :: {Integer} -- s0 = 0 :: Integer +-- set = {0} :: {Integer} -- -- >>> prove $ \x (s :: SSet Integer) -> x `notMember` (x `delete` s) -- Q.E.D. @@ -292,8 +290,8 @@ -- -- >>> prove $ \x -> isFull (observe "set" (x `delete` (full :: SSet Integer))) -- Falsifiable. Counter-example: --- set = U - {2} :: {Integer} -- s0 = 2 :: Integer +-- set = U - {2} :: {Integer} -- -- >>> isFull (full :: SSet Integer) -- True diff --git a/Data/SBV/String.hs b/Data/SBV/String.hs --- a/Data/SBV/String.hs +++ b/Data/SBV/String.hs @@ -41,8 +41,9 @@ import qualified Prelude as P import Data.SBV.Core.Data hiding (SeqOp(..)) -import Data.SBV.Core.Data (SeqOp(SBVReverse)) import Data.SBV.Core.Model +import Data.SBV.Core.Data (SeqOp(SBVReverse)) +import Data.SBV.Core.Symbolic (registerSpecialFunction) import qualified Data.Char as C import Data.List (genericLength, genericIndex, genericDrop, genericTake) @@ -103,7 +104,7 @@ | True = subStr s 1 (length s - 1) --- | @`uncons` returns the pair of the first character and tail. Unspecified if the string is empty. +-- | @`uncons`@ returns the pair of the first character and tail. Unspecified if the string is empty. uncons :: SString -> (SChar, SString) uncons l = (head l, tail l) @@ -118,8 +119,7 @@ | True = subStr s 0 (length s - 1) --- | @`singleton` c@ is the string of length 1 that contains the only character --- whose value is the 8-bit value @c@. +-- | @`singleton` c@ is the string of length 1 that contains the only character @c@. -- -- >>> prove $ \c -> c .== literal 'A' .=> singleton c .== "A" -- Q.E.D. @@ -140,7 +140,7 @@ strToStrAt :: SString -> SInteger -> SString strToStrAt s offset = subStr s offset 1 --- | @`strToCharAt` s i@ is the 8-bit value stored at location @i@. Unspecified if +-- | @`strToCharAt` s i@ is the character stored at location @i@. Unspecified if -- index is out of bounds. -- -- >>> prove $ \i -> i .>= 0 .&& i .<= 4 .=> "AAAAA" `strToCharAt` i .== literal 'A' @@ -350,7 +350,9 @@ | True = SBV $ SVal KString $ Right $ cache r where r st = do sva <- sbvToSV st s - newExpr st KString (SBVApp (SeqOp (SBVReverse KString)) [sva]) + let op = SeqOp (SBVReverse KString) + registerSpecialFunction st op + newExpr st KString (SBVApp op [sva]) -- | @`strToNat` s@. Retrieve integer encoded by string @s@ (ground rewriting only). -- Note that by definition this function only works when @s@ only contains digits, diff --git a/Data/SBV/Tools/BoundedFix.hs b/Data/SBV/Tools/BoundedFix.hs deleted file mode 100644 --- a/Data/SBV/Tools/BoundedFix.hs +++ /dev/null @@ -1,88 +0,0 @@ ------------------------------------------------------------------------------ --- | --- Module : Data.SBV.Tools.BoundedFix --- Copyright : (c) Levent Erkok --- License : BSD3 --- Maintainer: erkokl@gmail.com --- Stability : experimental --- --- Bounded fixed-point unrolling. ------------------------------------------------------------------------------ - -{-# LANGUAGE FlexibleContexts #-} - -{-# OPTIONS_GHC -Wall -Werror #-} - -module Data.SBV.Tools.BoundedFix ( - bfix - ) where - -import Data.SBV - --- $setup --- >>> -- For doctest purposes only: --- >>> import Data.SBV --- >>> bfac = bfix 10 "fac" fact where fact f n = ite (n .== 0) 1 ((n :: SInteger) * f (n-1)) - --- | Bounded fixed-point operation. The call @bfix bnd nm f@ unrolls the recursion in @f@ at most --- @bnd@ times, and uninterprets the function (with the name @nm@) after the bound is reached. --- --- This combinator is handy for dealing with recursive definitions that are not symbolically terminating --- and when the property we are interested in does not require an infinite unrolling, or when we are happy --- with a bounded proof. In particular, this operator can be used as a basis of software-bounded model --- checking algorithms built on top of SBV. The bound can be successively refined in a CEGAR like loop --- as necessary, by analyzing the counter-examples and rejecting them if they are false-negatives. --- --- For instance, we can define the factorial function using the bounded fixed-point operator like this: --- --- @ --- bfac :: SInteger -> SInteger --- bfac = bfix 10 "fac" fact --- where fact f n = ite (n .== 0) 1 (n * f (n-1)) --- @ --- --- This definition unrolls the recursion in factorial at most 10 times before uninterpreting the result. --- We can now prove: --- --- >>> prove $ \n -> n .>= 1 .&& n .<= 9 .=> bfac n .== n * bfac (n-1) --- Q.E.D. --- --- And we would get a bogus counter-example if the proof of our property needs a larger bound: --- --- >>> prove $ \n -> n .== 10 .=> bfac n .== 3628800 --- Falsifiable. Counter-example: --- s0 = 10 :: Integer --- --- fac :: Integer -> Integer --- fac _ = 2 --- --- The counter-example is telling us how it instantiated the function @fac@ when the recursion --- bottomed out: It simply made it return @2@ for all arguments at that point, which provides --- the (unintended) counter-example. --- --- By design, if a function defined via `bfix` is given a concrete argument, it will unroll --- the recursion as much as necessary to complete the call (which can of course diverge). The bound --- only applies if the given argument is symbolic. This fact can be used to observe concrete --- values to see where the bounded-model-checking approach fails: --- --- >>> prove $ \n -> n .== 10 .=> observe "bfac_n" (bfac n) .== observe "bfac_10" (bfac 10) --- Falsifiable. Counter-example: --- bfac_10 = 3628800 :: Integer --- bfac_n = 7257600 :: Integer --- s0 = 10 :: Integer --- --- fac :: Integer -> Integer --- fac _ = 2 --- --- Here, we see further evidence that the SMT solver must have decided to assign the --- value @2@ in the final call just as it was reaching the base case, and thus got the --- final result incorrect. (Note that @7257600 = 2 * 3628800@.) A wrapper algorithm can --- then assert the actual value of @bfac 10@ here as an extra constraint and can --- search for "deeper bugs." -bfix :: (SymVal a, SMTDefinable (SBV a -> r)) => Int -> String -> ((SBV a -> r) -> (SBV a -> r)) -> SBV a -> r -bfix bound nm f x - | isConcrete x = g x - | True = unroll bound x - where g = f g - unroll 0 = uninterpret nm - unroll i = f (unroll (i-1)) diff --git a/Data/SBV/Tools/BoundedList.hs b/Data/SBV/Tools/BoundedList.hs deleted file mode 100644 --- a/Data/SBV/Tools/BoundedList.hs +++ /dev/null @@ -1,150 +0,0 @@ ------------------------------------------------------------------------------ --- | --- Module : Data.SBV.Tools.BoundedList --- Copyright : (c) Levent Erkok --- License : BSD3 --- Maintainer: erkokl@gmail.com --- Stability : experimental --- --- A collection of bounded list utilities, useful when working with symbolic lists. --- These functions all take a concrete bound, and operate on the prefix of a symbolic --- list that is at most that long. Due to limitations on writing recursive functions --- over lists (the classic symbolic termination problem), we cannot write arbitrary --- recursive programs on symbolic lists. But most of the time all we need is a --- bounded prefix of this list, at which point these functions come in handy. ------------------------------------------------------------------------------ - -{-# LANGUAGE FlexibleContexts #-} -{-# LANGUAGE OverloadedLists #-} -{-# LANGUAGE Rank2Types #-} -{-# LANGUAGE ScopedTypeVariables #-} - -{-# OPTIONS_GHC -Wall -Werror #-} - -module Data.SBV.Tools.BoundedList ( - -- * General folds - bfoldr, bfoldrM, bfoldl, bfoldlM - -- * Map, filter, zipWith, elem - , bmap, bmapM, bfilter, bzipWith, belem - -- * Aggregates - , bsum, bprod, band, bor, bany, ball, bmaximum, bminimum - -- * Miscellaneous: Reverse and sort - , breverse, bsort - ) - where - -import Prelude hiding ((++)) - -import Data.SBV -import Data.SBV.List ((.:), (++)) -import qualified Data.SBV.List as L - --- | Case analysis on a symbolic list. (Not exported.) -lcase :: (SymVal a, Mergeable b) => SList a -> b -> (SBV a -> SList a -> b) -> b -lcase s e c = ite (L.null s) e (c (L.head s) (L.tail s)) - --- | Bounded fold from the right. -bfoldr :: (SymVal a, SymVal b) => Int -> (SBV a -> SBV b -> SBV b) -> SBV b -> SList a -> SBV b -bfoldr cnt f b = go (cnt `max` 0) - where go 0 _ = b - go i s = lcase s b (\h t -> h `f` go (i-1) t) - --- | Bounded monadic fold from the right. -bfoldrM :: forall a b m. (SymVal a, SymVal b, Monad m, Mergeable (m (SBV b))) - => Int -> (SBV a -> SBV b -> m (SBV b)) -> SBV b -> SList a -> m (SBV b) -bfoldrM cnt f b = go (cnt `max` 0) - where go :: Int -> SList a -> m (SBV b) - go 0 _ = return b - go i s = lcase s (return b) (\h t -> f h =<< go (i-1) t) - --- | Bounded fold from the left. -bfoldl :: (SymVal a, SymVal b) => Int -> (SBV b -> SBV a -> SBV b) -> SBV b -> SList a -> SBV b -bfoldl cnt f = go (cnt `max` 0) - where go 0 b _ = b - go i b s = lcase s b (\h t -> go (i-1) (b `f` h) t) - --- | Bounded monadic fold from the left. -bfoldlM :: forall a b m. (SymVal a, SymVal b, Monad m, Mergeable (m (SBV b))) - => Int -> (SBV b -> SBV a -> m (SBV b)) -> SBV b -> SList a -> m (SBV b) -bfoldlM cnt f = go (cnt `max` 0) - where go :: Int -> SBV b -> SList a -> m (SBV b) - go 0 b _ = return b - go i b s = lcase s (return b) (\h t -> do { fbh <- f b h; go (i-1) fbh t }) - --- | Bounded sum. -bsum :: (SymVal a, Num a, Num (SBV a), Ord a) => Int -> SList a -> SBV a -bsum i = bfoldl i (+) 0 - --- | Bounded product. -bprod :: (SymVal a, Num a, Num (SBV a), Ord a) => Int -> SList a -> SBV a -bprod i = bfoldl i (*) 1 - --- | Bounded map. -bmap :: (SymVal a, SymVal b) => Int -> (SBV a -> SBV b) -> SList a -> SList b -bmap i f = bfoldr i (\x -> (f x .:)) [] - --- | Bounded monadic map. -bmapM :: (SymVal a, SymVal b, Monad m, Mergeable (m (SBV [b]))) - => Int -> (SBV a -> m (SBV b)) -> SList a -> m (SList b) -bmapM i f = bfoldrM i (\a bs -> (.:) <$> f a <*> pure bs) [] - --- | Bounded filter. -bfilter :: SymVal a => Int -> (SBV a -> SBool) -> SList a -> SList a -bfilter i f = bfoldr i (\x y -> ite (f x) (x .: y) y) [] - --- | Bounded logical and -band :: Int -> SList Bool -> SBool -band i = bfoldr i (.&&) (sTrue :: SBool) - --- | Bounded logical or -bor :: Int -> SList Bool -> SBool -bor i = bfoldr i (.||) (sFalse :: SBool) - --- | Bounded any -bany :: SymVal a => Int -> (SBV a -> SBool) -> SList a -> SBool -bany i f = bor i . bmap i f - --- | Bounded all -ball :: SymVal a => Int -> (SBV a -> SBool) -> SList a -> SBool -ball i f = band i . bmap i f - --- | Bounded maximum. Undefined if list is empty. -bmaximum :: (Ord a, SymVal a) => Int -> SList a -> SBV a -bmaximum i l = bfoldl (i-1) smax (L.head l) (L.tail l) - --- | Bounded minimum. Undefined if list is empty. -bminimum :: (Ord a, SymVal a) => Int -> SList a -> SBV a -bminimum i l = bfoldl (i-1) smin (L.head l) (L.tail l) - --- | Bounded zipWith -bzipWith :: (SymVal a, SymVal b, SymVal c) => Int -> (SBV a -> SBV b -> SBV c) -> SList a -> SList b -> SList c -bzipWith cnt f = go (cnt `max` 0) - where go 0 _ _ = [] - go i xs ys = ite (L.null xs .|| L.null ys) - [] - (f (L.head xs) (L.head ys) .: go (i-1) (L.tail xs) (L.tail ys)) - --- | Bounded element check -belem :: (Eq a, SymVal a) => Int -> SBV a -> SList a -> SBool -belem i e = bany i (e .==) - --- | Bounded reverse -breverse :: SymVal a => Int -> SList a -> SList a -breverse cnt = bfoldr cnt (\a b -> b ++ L.singleton a) [] - --- | Bounded paramorphism (not exported). -bpara :: (SymVal a, SymVal b) => Int -> (SBV a -> SBV [a] -> SBV b -> SBV b) -> SBV b -> SList a -> SBV b -bpara cnt f b = go (cnt `max` 0) - where go 0 _ = b - go i s = lcase s b (\h t -> f h t (go (i-1) t)) - --- | Insert an element into a sorted list (not exported). -binsert :: (Ord a, SymVal a) => Int -> SBV a -> SList a -> SList a -binsert cnt a = bpara cnt f (L.singleton a) - where f sortedHd sortedTl sortedTl' = ite (a .< sortedHd) - (a .: sortedHd .: sortedTl) - (sortedHd .: sortedTl') - --- | Bounded insertion sort -bsort :: (Ord a, SymVal a) => Int -> SList a -> SList a -bsort cnt = bfoldr cnt (binsert cnt) [] diff --git a/Data/SBV/Tools/KD/Kernel.hs b/Data/SBV/Tools/KD/Kernel.hs new file mode 100644 --- /dev/null +++ b/Data/SBV/Tools/KD/Kernel.hs @@ -0,0 +1,226 @@ +----------------------------------------------------------------------------- +-- | +-- Module : Data.SBV.Tools.KD.Kernel +-- Copyright : (c) Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Kernel of the KnuckleDragger prover API. +----------------------------------------------------------------------------- + +{-# LANGUAGE ConstraintKinds #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleContexts #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE NamedFieldPuns #-} +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE TypeAbstractions #-} + +{-# OPTIONS_GHC -Wall -Werror #-} + +module Data.SBV.Tools.KD.Kernel ( + Proposition, Proof(..) + , axiom + , lemma, lemmaWith, lemmaGen + , theorem, theoremWith + , sorry + , internalAxiom + , checkSatThen + ) where + +import Control.Monad.Trans (liftIO, MonadIO) + +import Data.List (intercalate) +import Data.Maybe (catMaybes, fromMaybe) + +import Data.SBV.Core.Data hiding (None) +import Data.SBV.Core.Symbolic (isEmptyModel) +import Data.SBV.Control hiding (getProof) + +import Data.SBV.SMT.SMT +import Data.SBV.Core.Model +import Data.SBV.Provers.Prover + +import Data.SBV.Tools.KD.Utils + +import Data.Time (NominalDiffTime) +import Data.SBV.Utils.TDiff + +import Data.Dynamic + +-- | A proposition is something SBV is capable of proving/disproving in KnuckleDragger. +type Proposition a = ( QNot a + , QuantifiedBool a + , QSaturate Symbolic a + , Skolemize (NegatesTo a) + , Satisfiable (Symbolic (SkolemsTo (NegatesTo a))) + , Constraint Symbolic (SkolemsTo (NegatesTo a)) + , Typeable a + ) + +-- | Accept the given definition as a fact. Usually used to introduce definitial axioms, +-- giving meaning to uninterpreted symbols. Note that we perform no checks on these propositions, +-- if you assert nonsense, then you get nonsense back. So, calls to 'axiom' should be limited to +-- definitions, or basic axioms (like commutativity, associativity) of uninterpreted function symbols. +axiom :: Proposition a => String -> a -> KD Proof +axiom nm p = do cfg <- getKDConfig + _ <- liftIO $ startKD cfg True "Axiom" [nm] + pure (internalAxiom nm p) { isUserAxiom = True } + +-- | Internal axiom generator; so we can keep truck of KnuckleDrugger's trusted axioms, vs. user given axioms. +internalAxiom :: Proposition a => String -> a -> Proof +internalAxiom nm p = Proof { rootOfTrust = None + , isUserAxiom = False + , getProof = label nm (quantifiedBool p) + , getProp = toDyn p + , proofName = nm + } + +-- | A manifestly false theorem. This is useful when we want to prove a theorem that the underlying solver +-- cannot deal with, or if we want to postpone the proof for the time being. KnuckleDragger will keep +-- track of the uses of 'sorry' and will print them appropriately while printing proofs. +sorry :: Proof +sorry = Proof { rootOfTrust = Self + , isUserAxiom = False + , getProof = label "sorry" (quantifiedBool p) + , getProp = toDyn p + , proofName = "sorry" + } + where -- ideally, I'd rather just use + -- p = sFalse + -- but then SBV constant folds the boolean, and the generated script + -- doesn't contain the actual contents, as SBV determines unsatisfiability + -- itself. By using the following proposition (which is easy for the backend + -- solver to determine as false, we avoid the constant folding. + p (Forall @"__sbvKD_sorry" (x :: SBool)) = label "SORRY: KnuckleDragger, proof uses \"sorry\"" x + +-- | Helper to generate lemma/theorem statements. +lemmaGen :: Proposition a => SMTConfig -> String -> [String] -> a -> [Proof] -> KD Proof +lemmaGen cfg@SMTConfig{kdOptions = KDOptions{measureTime}} tag nms inputProp by = do + kdSt <- getKDState + liftIO $ getTimeStampIf measureTime >>= runSMTWith cfg . go kdSt + where go kdSt mbStartTime = do qSaturateSavingObservables inputProp + mapM_ (constrain . getProof) by + query $ checkSatThen cfg kdSt tag False Nothing inputProp by nms Nothing Nothing (good mbStartTime) + + -- What to do if all goes well + good mbStart d = do mbElapsed <- getElapsedTime mbStart + liftIO $ finishKD cfg ("Q.E.D." ++ modulo) d $ catMaybes [mbElapsed] + pure Proof { rootOfTrust = ros + , isUserAxiom = False + , getProof = label nm (quantifiedBool inputProp) + , getProp = toDyn inputProp + , proofName = nm + } + where (ros, modulo) = calculateRootOfTrust nm by + nm = intercalate "." nms + +-- | Prove a given statement, using auxiliaries as helpers. Using the default solver. +lemma :: Proposition a => String -> a -> [Proof] -> KD Proof +lemma nm f by = do cfg <- getKDConfig + lemmaWith cfg nm f by + +-- | Prove a given statement, using auxiliaries as helpers. Using the given solver. +lemmaWith :: Proposition a => SMTConfig -> String -> a -> [Proof] -> KD Proof +lemmaWith cfg nm = lemmaGen cfg "Lemma" [nm] + +-- | Prove a given statement, using auxiliaries as helpers. Essentially the same as 'lemma', except for the name, using the default solver. +theorem :: Proposition a => String -> a -> [Proof] -> KD Proof +theorem nm f by = do cfg <- getKDConfig + theoremWith cfg nm f by + +-- | Prove a given statement, using auxiliaries as helpers. Essentially the same as 'lemmaWith', except for the name. +theoremWith :: Proposition a => SMTConfig -> String -> a -> [Proof] -> KD Proof +theoremWith cfg nm = lemmaGen cfg "Theorem" [nm] + +-- | Capture the general flow after a checkSat. We run the sat case if model is empty. +-- NB. This is the only place in Knuckledragger where we actually call check-sat; +-- so all interaction goes through here. +checkSatThen :: (SolverContext m, MonadIO m, MonadQuery m, Proposition a) + => SMTConfig -- ^ config + -> KDState -- ^ KDState + -> String -- ^ tag + -> Bool -- in query mode already (True), or lemmaGen (False)? + -> Maybe SBool -- ^ context if any. If there's one we'll push/pop + -> a -- ^ what we want to prove + -> [Proof] -- ^ helpers in the context. NB. Only used for printing cex's. We assume they're already asserted. + -> [String] -- ^ sub-proof + -> Maybe [String] -- ^ full-path to the proof, if different than sub-proof + -> Maybe (IO ()) -- ^ special code to run if model is empty (if any) + -> ((Int, Maybe NominalDiffTime) -> IO r) -- ^ what to do when unsat, with the tab amount and time elapsed (if asked) + -> m r +checkSatThen cfg@SMTConfig{verbose, kdOptions = KDOptions{measureTime}} kdState tag inQuery mbCtx prop by nms fullNms mbSat unsat = do + + case mbCtx of + Just{} -> inNewAssertionStack check + Nothing -> check + + where check = do + tab <- liftIO $ startKD cfg verbose tag nms + + case mbCtx of + Nothing -> queryDebug ["; checkSatThen: No context value to push."] + Just ctx -> do queryDebug ["; checkSatThen: Pushing in the context: " ++ show ctx] + constrain ctx + + -- It's tempting to skolemize here.. But skolemization creates fresh constants + -- based on the name given, and they mess with all else. So, don't skolemize! + constrain $ sNot (quantifiedBool prop) + + (mbT, r) <- timeIf measureTime checkSat + + updStats kdState (\s -> s{noOfCheckSats = noOfCheckSats s + 1}) + + case mbT of + Nothing -> pure () + Just t -> updStats kdState (\s -> s{solverElapsed = solverElapsed s + t}) + + case r of + Unk -> unknown + Sat -> cex + DSat{} -> cex + Unsat -> liftIO $ unsat (tab, mbT) + + die = error "Failed" + + fullNm = intercalate "." (filter (not . null) (fromMaybe nms fullNms)) + + unknown = do r <- getUnknownReason + liftIO $ do putStrLn $ "\n*** Failed to prove " ++ fullNm ++ "." + putStrLn $ "\n*** Solver reported: " ++ show r + die + + -- What to do if the proof fails + cex = do liftIO $ putStrLn $ "\n*** Failed to prove " ++ fullNm ++ "." + + res <- if inQuery + then Satisfiable cfg <$> getModel + else -- When trying to get a counter-example not in query mode, we + -- do a skolemized sat call, which gets better counter-examples. + -- We only include the those facts that are user-given axioms. This + -- way our counter-example will be more likely to be relevant + -- to the proposition we're currently proving. (Hopefully.) + -- Remember that we first have to negate, and then skolemize! + do SatResult res <- liftIO $ satWith cfg $ do + qSaturateSavingObservables prop + mapM_ constrain [getProof | Proof{isUserAxiom, getProof} <- by, isUserAxiom] :: Symbolic () + pure $ skolemize (qNot prop) + pure res + + let isEmpty = case res of + Unsatisfiable{} -> -- Shouldn't really happen! bail out + error $ unlines [" SBV.KnuckleDragger: Unexpected unsat-result while extracting a model." + , "Please report this as a bug!" + ] + Satisfiable _ m -> isEmptyModel m -- Expected case + DeltaSat _ _ m -> isEmptyModel m -- Unlikely but why not + SatExtField _ m -> isEmptyModel m -- Can't really happen + Unknown{} -> False -- Possible, I suppose. Just print it + ProofError{} -> False -- Ditto + + liftIO $ case (isEmpty, mbSat) of + (True, Just act) -> act + _ -> print $ ThmResult res + + die diff --git a/Data/SBV/Tools/KD/KnuckleDragger.hs b/Data/SBV/Tools/KD/KnuckleDragger.hs new file mode 100644 --- /dev/null +++ b/Data/SBV/Tools/KD/KnuckleDragger.hs @@ -0,0 +1,809 @@ +----------------------------------------------------------------------------- +-- | +-- Module : Data.SBV.Tools.KD.KnuckleDragger +-- Copyright : (c) Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- A lightweight theorem proving like interface, built on top of SBV. +-- Inspired by and modeled after Philip Zucker's tool with the same +-- name, see . +-- +-- See the directory Documentation.SBV.Examples.KnuckleDragger for various examples. +----------------------------------------------------------------------------- + +{-# LANGUAGE ConstraintKinds #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DerivingStrategies #-} +{-# LANGUAGE FlexibleContexts #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE NamedFieldPuns #-} +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE TypeAbstractions #-} +{-# LANGUAGE TypeApplications #-} +{-# LANGUAGE TypeFamilies #-} + +{-# OPTIONS_GHC -Wall -Werror #-} + +module Data.SBV.Tools.KD.KnuckleDragger ( + Proposition, Proof, Instantiatable(..), Inst(..) + , axiom + , lemma, lemmaWith + , theorem, theoremWith + , calc, calcWith, calcThm, calcThmWith + , induct, inductWith, inductThm, inductThmWith + , sorry + , KD, runKD, runKDWith, use + , (|-), (⊢), (=:), (≡), (?), hyp, hprf, qed + ) where + +import Data.SBV +import Data.SBV.Core.Model (qSaturateSavingObservables) + +import Data.SBV.Control hiding (getProof) + +import Data.SBV.Tools.KD.Kernel +import Data.SBV.Tools.KD.Utils + +import Control.Monad.Trans (liftIO) + +import qualified Data.SBV.List as SL + +import Data.Char (isSpace) +import Data.List (isPrefixOf, isSuffixOf) +import Data.Maybe (catMaybes) + +import Data.Proxy +import GHC.TypeLits (KnownSymbol, symbolVal, Symbol) + +import Data.SBV.Utils.TDiff + +import Data.Dynamic + +-- | Bring an IO proof into current proof context. +use :: IO Proof -> KD Proof +use = liftIO + +-- | A class for doing equational reasoning style calculational proofs. Use 'calc' to prove a given theorem +-- as a sequence of equalities, each step following from the previous. +class CalcLemma a steps where + + -- | Prove a property via a series of equality steps, using the default solver. + -- Let @H@ be a list of already established lemmas. Let @P@ be a property we wanted to prove, named @name@. + -- Consider a call of the form @calc name P (cond, [A, B, C, D]) H@. Note that @H@ is + -- a list of already proven facts, ensured by the type signature. We proceed as follows: + -- + -- * Prove: @(H && cond) -> (A == B)@ + -- * Prove: @(H && cond && A == B) -> (B == C)@ + -- * Prove: @(H && cond && A == B && B == C) -> (C == D)@ + -- * Prove: @(H && (cond -> (A == B && B == C && C == D))) -> P@ + -- * If all of the above steps succeed, conclude @P@. + -- + -- cond acts as the context. Typically, if you are trying to prove @Y -> Z@, then you want cond to be Y. + -- (This is similar to @intros@ commands in theorem provers.) + -- + -- So, calc-lemma is essentially modus-ponens, applied in a sequence of stepwise equality reasoning in the case of + -- non-boolean steps. + -- + -- If there are no helpers given (i.e., if @H@ is empty), then this call is equivalent to 'lemmaWith'. + -- If @H@ is a singleton, then we bail out. A single step in @H@ indicates a usage mistake, since there's + -- no sequence of steps to reason about. + calc :: Proposition a => String -> a -> steps -> KD Proof + + -- | Same as calc, except tagged as Theorem + calcThm :: Proposition a => String -> a -> steps -> KD Proof + + -- | Prove a property via a series of equality steps, using the given solver. + calcWith :: Proposition a => SMTConfig -> String -> a -> steps -> KD Proof + + -- | Same as calcWith, except tagged as Theorem + calcThmWith :: Proposition a => SMTConfig -> String -> a -> steps -> KD Proof + + -- | Internal, shouldn't be needed outside the library + {-# MINIMAL calcSteps #-} + calcSteps :: a -> steps -> Symbolic (SBool, (SBool, [([Helper], SBool)])) + + calc nm p steps = getKDConfig >>= \cfg -> calcWith cfg nm p steps + calcThm nm p steps = getKDConfig >>= \cfg -> calcThmWith cfg nm p steps + calcWith = calcGeneric False + calcThmWith = calcGeneric True + + calcGeneric :: Proposition a => Bool -> SMTConfig -> String -> a -> steps -> KD Proof + calcGeneric tagTheorem cfg@SMTConfig{kdOptions = KDOptions{measureTime}} nm result steps = do + kdSt <- getKDState + + liftIO $ runSMTWith cfg $ do + + qSaturateSavingObservables result -- make sure we saturate the result, i.e., get all it's UI's, types etc. pop out + + message cfg $ (if tagTheorem then "Theorem" else "Lemma") ++ ": " ++ nm ++ "\n" + + mbStartTime <- getTimeStampIf measureTime + + (goal, (calcIntros, proofSteps)) <- calcSteps result steps + + let stepHelpers = concatMap fst proofSteps + (ros, modulo) = calculateRootOfTrust nm [p | HProof p <- stepHelpers] + finish = finishKD cfg ("Q.E.D." ++ modulo) + + mapM_ (qSaturateSavingObservables . getHelperBool) stepHelpers + + let go :: Int -> SBool -> [([Helper], SBool)] -> Query Proof + go _ accum [] = do + queryDebug [nm ++ ": Proof end: proving the result:"] + checkSatThen cfg kdSt "Result" True + (Just (calcIntros .=> accum)) + goal + [] + ["", ""] + (Just [nm, "Result"]) + Nothing $ \d -> do mbElapsed <- getElapsedTime mbStartTime + finish d $ catMaybes [mbElapsed] + pure Proof { rootOfTrust = ros + , isUserAxiom = False + , getProof = label nm (quantifiedBool result) + , getProp = toDyn result + , proofName = nm + } + + go i accum ((by, s):ss) = do + + -- Prove that the assumptions follow, if any + case [a | HAssum a <- by] of + [] -> pure () + as -> checkSatThen cfg kdSt "Asms " + True + (Just calcIntros) + (sAnd as) + [] + ["", show i] + (Just [nm, show i]) + Nothing + (`finish` []) + + queryDebug [nm ++ ": Proof step: " ++ show i ++ " to " ++ show (i+1) ++ ":"] + checkSatThen cfg kdSt "Step " + True + (Just (sAnd (map getHelperBool by))) + s + [] + ["", show i] + (Just [nm, show i]) + Nothing + (`finish` []) + + go (i+1) (s .&& accum) ss + + query $ go (1::Int) sTrue proofSteps + +-- | Turn a sequence of steps into a chain of equalities +mkCalcSteps :: EqSymbolic a => (SBool, [ProofStep a]) -> (SBool, [([Helper], SBool)]) +mkCalcSteps (intros, xs) = (intros, zipWith merge xs (drop 1 xs)) + where merge (ProofStep a by) (ProofStep b _) = (by, a .== b) + +-- | Chaining lemmas that depend on a single quantified variable. +instance (KnownSymbol na, SymVal a, EqSymbolic z) => CalcLemma (Forall na a -> SBool) (SBV a -> (SBool, [ProofStep z])) where + calcSteps result steps = do a <- free (symbolVal (Proxy @na)) + pure (result (Forall a), mkCalcSteps (steps a)) + +-- | Chaining lemmas that depend on two quantified variables. +instance (KnownSymbol na, SymVal a, KnownSymbol nb, SymVal b, EqSymbolic z) + => CalcLemma (Forall na a -> Forall nb b -> SBool) + (SBV a -> SBV b -> (SBool, [ProofStep z])) where + calcSteps result steps = do (a, b) <- (,) <$> free (symbolVal (Proxy @na)) <*> free (symbolVal (Proxy @nb)) + pure (result (Forall a) (Forall b), mkCalcSteps (steps a b)) + +-- | Chaining lemmas that depend on three quantified variables. +instance (KnownSymbol na, SymVal a, KnownSymbol nb, SymVal b, KnownSymbol nc, SymVal c, EqSymbolic z) + => CalcLemma (Forall na a -> Forall nb b -> Forall nc c -> SBool) + (SBV a -> SBV b -> SBV c -> (SBool, [ProofStep z])) where + calcSteps result steps = do (a, b, c) <- (,,) <$> free (symbolVal (Proxy @na)) <*> free (symbolVal (Proxy @nb)) <*> free (symbolVal (Proxy @nc)) + pure (result (Forall a) (Forall b) (Forall c), mkCalcSteps (steps a b c)) + +-- | Chaining lemmas that depend on four quantified variables. +instance (KnownSymbol na, SymVal a, KnownSymbol nb, SymVal b, KnownSymbol nc, SymVal c, KnownSymbol nd, SymVal d, EqSymbolic z) + => CalcLemma (Forall na a -> Forall nb b -> Forall nc c -> Forall nd d -> SBool) + (SBV a -> SBV b -> SBV c -> SBV d -> (SBool, [ProofStep z])) where + calcSteps result steps = do (a, b, c, d) <- (,,,) <$> free (symbolVal (Proxy @na)) <*> free (symbolVal (Proxy @nb)) <*> free (symbolVal (Proxy @nc)) <*> free (symbolVal (Proxy @nd)) + pure (result (Forall a) (Forall b) (Forall c) (Forall d), mkCalcSteps (steps a b c d)) + +-- | Chaining lemmas that depend on five quantified variables. +instance (KnownSymbol na, SymVal a, KnownSymbol nb, SymVal b, KnownSymbol nc, SymVal c, KnownSymbol nd, SymVal d, KnownSymbol ne, SymVal e, EqSymbolic z) + => CalcLemma (Forall na a -> Forall nb b -> Forall nc c -> Forall nd d -> Forall ne e -> SBool) + (SBV a -> SBV b -> SBV c -> SBV d -> SBV e -> (SBool, [ProofStep z])) where + calcSteps result steps = do (a, b, c, d, e) <- (,,,,) <$> free (symbolVal (Proxy @na)) <*> free (symbolVal (Proxy @nb)) <*> free (symbolVal (Proxy @nc)) <*> free (symbolVal (Proxy @nd)) <*> free (symbolVal (Proxy @ne)) + pure (result (Forall a) (Forall b) (Forall c) (Forall d) (Forall e), mkCalcSteps (steps a b c d e)) + +-- | Captures the schema for an inductive proof +data InductionStrategy = InductionStrategy { inductionIntros :: SBool + , inductionBaseCase :: SBool + , inductionProofSteps :: [([Helper], SBool)] + , inductionBaseFailureMsg :: String + , inductiveStep :: SBool + } + +-- | A class for doing inductive proofs, with the possibility of explicit steps. +class Inductive a steps where + -- | Inductively prove a lemma, using the default config. + induct :: Proposition a => String -> a -> (Proof -> steps) -> KD Proof + + -- | Inductively prove a theorem. Same as 'induct', but tagged as a theorem, using the default config. + inductThm :: Proposition a => String -> a -> (Proof -> steps) -> KD Proof + + -- | Same as 'induct', but with the given solver configuration. + inductWith :: Proposition a => SMTConfig -> String -> a -> (Proof -> steps) -> KD Proof + + -- | Same as 'inductiveTheorem, but with the given solver configuration. + inductThmWith :: Proposition a => SMTConfig -> String -> a -> (Proof -> steps) -> KD Proof + + induct nm p steps = getKDConfig >>= \cfg -> inductWith cfg nm p steps + inductThm nm p steps = getKDConfig >>= \cfg -> inductThmWith cfg nm p steps + inductWith = inductGeneric False + inductThmWith = inductGeneric True + + -- | Internal, shouldn't be needed outside the library + {-# MINIMAL inductionStrategy #-} + inductionStrategy :: Proposition a => a -> (Proof -> steps) -> Symbolic InductionStrategy + + inductGeneric :: Proposition a => Bool -> SMTConfig -> String -> a -> (Proof -> steps) -> KD Proof + inductGeneric tagTheorem cfg@SMTConfig{kdOptions = KDOptions{measureTime}} nm result steps = do + kdSt <- getKDState + + liftIO $ runSMTWith cfg $ do + + qSaturateSavingObservables result -- make sure we saturate the result, i.e., get all it's UI's, types etc. pop out + + message cfg $ "Inductive " ++ (if tagTheorem then "theorem" else "lemma") ++ ": " ++ nm ++ "\n" + + mbStartTime <- getTimeStampIf measureTime + + InductionStrategy { inductionIntros + , inductionBaseCase + , inductionProofSteps + , inductionBaseFailureMsg + , inductiveStep + } <- inductionStrategy result steps + + let stepHelpers = concatMap fst inductionProofSteps + (ros, modulo) = calculateRootOfTrust nm [p | HProof p <- stepHelpers] + finish et d = finishKD cfg ("Q.E.D." ++ modulo) d et + + mapM_ (qSaturateSavingObservables . getHelperBool) stepHelpers + + query $ do + + queryDebug [nm ++ ": Induction, proving base case:"] + checkSatThen cfg kdSt "Base" True (Just inductionIntros) inductionBaseCase [] [nm, "Base"] Nothing + (Just (liftIO (putStrLn inductionBaseFailureMsg))) + (finish []) + + let loop i accum ((by, s):ss) = do + + -- Prove that the assumptions follow, if any + case [a | HAssum a <- by] of + [] -> pure () + as -> checkSatThen cfg kdSt "Asms" + True + (Just inductionIntros) + (sAnd as) + [] + ["", show i] + (Just [nm, show i]) + Nothing + (finish []) + + queryDebug [nm ++ ": Induction, proving step: " ++ show i] + checkSatThen cfg kdSt "Step" + True + (Just (sAnd (map getHelperBool by))) + s + [] + ["", show i] + (Just [nm, show i]) + Nothing + (finish []) + loop (i+1) (accum .&& s) ss + + loop _ accum [] = pure accum + + -- Get the schema + indSchema <- loop (1::Int) sTrue inductionProofSteps + + -- Do the final proof: + queryDebug [nm ++ ": Induction, proving inductive step:"] + checkSatThen cfg kdSt "Step" + True + (Just (inductionIntros .=> indSchema)) + inductiveStep + [] + [nm, "Step"] + Nothing + Nothing $ \d -> do + mbElapsed <- getElapsedTime mbStartTime + finish (catMaybes [mbElapsed]) d + pure $ Proof { rootOfTrust = ros + , isUserAxiom = False + , getProof = label nm $ quantifiedBool result + , getProp = toDyn result + , proofName = nm + } + +-- | Induction over 'SInteger'. +instance (KnownSymbol nk, EqSymbolic z) => Inductive (Forall nk Integer -> SBool) (SInteger -> (SBool, [ProofStep z])) where + inductionStrategy result steps = do + let predicate k = result (Forall k) + nk = symbolVal (Proxy @nk) + + k <- free nk + + let ih = internalAxiom "IH" $ predicate k + (intros, pSteps) = mkCalcSteps $ steps ih k + + pure InductionStrategy { + inductionIntros = k .>= 0 .&& intros + , inductionBaseCase = predicate 0 + , inductionProofSteps = pSteps + , inductionBaseFailureMsg = "Property fails for " ++ nk ++ " = 0." + , inductiveStep = observeIf not ("P(" ++ nk ++ "+1)") (predicate (k+1)) + } + +-- | Induction over 'SInteger' taking an extra argument. +instance forall na a nk z. (KnownSymbol na, SymVal a, KnownSymbol nk, EqSymbolic z) + => Inductive (Forall nk Integer -> Forall na a -> SBool) + (SInteger -> SBV a -> (SBool, [ProofStep z])) where + inductionStrategy result steps = do + let predicate k a = result (Forall k) (Forall a) + nk = symbolVal (Proxy @nk) + na = symbolVal (Proxy @na) + + k <- free nk + a <- free na + + let ih = internalAxiom "IH" $ \a' -> result (Forall k) (a' :: Forall na a) + (intros, pSteps) = mkCalcSteps $ steps ih k a + + pure InductionStrategy { + inductionIntros = k .>= 0 .&& intros + , inductionBaseCase = predicate 0 a + , inductionProofSteps = pSteps + , inductionBaseFailureMsg = "Property fails for " ++ nk ++ " = 0." + , inductiveStep = observeIf not ("P(" ++ nk ++ "+1)") (predicate (k+1) a) + } + +-- | Induction over 'SInteger' taking two extra arguments. +instance forall na a nb b nk z. (KnownSymbol na, SymVal a, KnownSymbol nb, SymVal b, KnownSymbol nk, EqSymbolic z) + => Inductive (Forall nk Integer -> Forall na a -> Forall nb b -> SBool) + (SInteger -> SBV a -> SBV b -> (SBool, [ProofStep z])) where + inductionStrategy result steps = do + let predicate k a b = result (Forall k) (Forall a) (Forall b) + nk = symbolVal (Proxy @nk) + na = symbolVal (Proxy @na) + nb = symbolVal (Proxy @nb) + + k <- free nk + a <- free na + b <- free nb + + let ih = internalAxiom "IH" $ \a' b' -> result (Forall k) (a' :: Forall na a) (b' :: Forall nb b) + (intros, pSteps) = mkCalcSteps $ steps ih k a b + + pure InductionStrategy { + inductionIntros = k .>= 0 .&& intros + , inductionBaseCase = predicate 0 a b + , inductionProofSteps = pSteps + , inductionBaseFailureMsg = "Property fails for " ++ nk ++ " = 0." + , inductiveStep = observeIf not ("P(" ++ nk ++ "+1)") (predicate (k+1) a b) + } + +-- | Induction over 'SInteger' taking three extra arguments. +instance forall na a nb b nc c nk z. (KnownSymbol na, SymVal a , KnownSymbol nb, SymVal b, KnownSymbol nc, SymVal c, KnownSymbol nk, EqSymbolic z) + => Inductive (Forall nk Integer -> Forall na a -> Forall nb b -> Forall nc c -> SBool) + (SInteger -> SBV a -> SBV b -> SBV c -> (SBool, [ProofStep z])) + where + inductionStrategy result steps = do + let predicate k a b c = result (Forall k) (Forall a) (Forall b) (Forall c) + nk = symbolVal (Proxy @nk) + na = symbolVal (Proxy @na) + nb = symbolVal (Proxy @nb) + nc = symbolVal (Proxy @nc) + + k <- free nk + a <- free na + b <- free nb + c <- free nc + + let ih = internalAxiom "IH" $ \a' b' c' -> result (Forall k) (a' :: Forall na a) (b' :: Forall nb b) (c' :: Forall nc c) + (intros, pSteps) = mkCalcSteps $ steps ih k a b c + + pure InductionStrategy { + inductionIntros = k .>= 0 .&& intros + , inductionBaseCase = predicate 0 a b c + , inductionProofSteps = pSteps + , inductionBaseFailureMsg = "Property fails for " ++ nk ++ " = 0." + , inductiveStep = observeIf not ("P(" ++ nk ++ "+1)") (predicate (k+1) a b c) + } + +-- | Induction over 'SInteger' taking four extra arguments. +instance forall na a nb b nc c nd d nk z. (KnownSymbol na, SymVal a, KnownSymbol nb, SymVal b, KnownSymbol nc, SymVal c, KnownSymbol nd, SymVal d, KnownSymbol nk, EqSymbolic z) + => Inductive (Forall nk Integer -> Forall na a -> Forall nb b -> Forall nc c -> Forall nd d -> SBool) + (SInteger -> SBV a -> SBV b -> SBV c -> SBV d -> (SBool, [ProofStep z])) where + inductionStrategy result steps = do + let predicate k a b c d = result (Forall k) (Forall a) (Forall b) (Forall c) (Forall d) + nk = symbolVal (Proxy @nk) + na = symbolVal (Proxy @na) + nb = symbolVal (Proxy @nb) + nc = symbolVal (Proxy @nc) + nd = symbolVal (Proxy @nd) + + k <- free nk + a <- free na + b <- free nb + c <- free nc + d <- free nd + + let ih = internalAxiom "IH" $ \a' b' c' d' -> result (Forall k) (a' :: Forall na a) (b' :: Forall nb b) (c' :: Forall nc c) (d' :: Forall nd d) + (intros, pSteps) = mkCalcSteps $ steps ih k a b c d + + pure InductionStrategy { + inductionIntros = k .>= 0 .&& intros + , inductionBaseCase = predicate 0 a b c d + , inductionProofSteps = pSteps + , inductionBaseFailureMsg = "Property fails for " ++ nk ++ " = 0." + , inductiveStep = observeIf not ("P(" ++ nk ++ "+1)") (predicate (k+1) a b c d) + } + +-- Given a user name for the list, get a name for the element, in the most suggestive way possible +-- xs -> x +-- xss -> xs +-- foo -> fooElt +singular :: String -> String +singular n = case reverse n of + 's':_:_ -> init n + _ -> n ++ "Elt" + +-- | Induction over 'SList'. +instance (KnownSymbol nk, SymVal k, EqSymbolic z) + => Inductive (Forall nk [k] -> SBool) + (SBV k -> SList k -> (SBool, [ProofStep z])) + where + inductionStrategy result steps = do + let predicate k = result (Forall k) + nks = symbolVal (Proxy @nk) + nk = singular nks + + k <- free nk + ks <- free nks + + let ih = internalAxiom "IH" $ predicate ks + (intros, pSteps) = mkCalcSteps $ steps ih k ks + + pure InductionStrategy { + inductionIntros = intros + , inductionBaseCase = predicate SL.nil + , inductionProofSteps = pSteps + , inductionBaseFailureMsg = "Property fails for " ++ nks ++ " = []." + , inductiveStep = observeIf not ("P(" ++ nk ++ ":" ++ nks ++ ")") (predicate (k SL..: ks)) + } + +-- | Induction over 'SList' taking an extra argument +instance forall na a nx x z. (KnownSymbol na, SymVal a, KnownSymbol nx, SymVal x, EqSymbolic z) + => Inductive (Forall nx [x] -> Forall na a -> SBool) + (SBV x -> SList x -> SBV a -> (SBool, [ProofStep z])) + where + inductionStrategy result steps = do + let predicate xs a = result (Forall xs) (Forall a) + na = symbolVal (Proxy @na) + nxs = symbolVal (Proxy @nx) + nx = singular nxs + + x <- free nx + xs <- free nxs + a <- free na + + let ih = internalAxiom "IH" $ \a' -> result (Forall xs) (a' :: Forall na a) + (intros, pSteps) = mkCalcSteps $ steps ih x xs a + + pure InductionStrategy { + inductionIntros = intros + , inductionBaseCase = predicate SL.nil a + , inductionProofSteps = pSteps + , inductionBaseFailureMsg = "Property fails for " ++ nxs ++ " = []." + , inductiveStep = observeIf not ("P(" ++ nx ++ ":" ++ nxs ++ ")") (predicate (x SL..: xs) a) + } + +-- | Induction over 'SList' taking two extra arguments +instance forall na a nb b nx x z. (KnownSymbol na, SymVal a, KnownSymbol nb, SymVal b, KnownSymbol nx, SymVal x, EqSymbolic z) + => Inductive (Forall nx [x] -> Forall na a -> Forall nb b -> SBool) + (SBV x -> SList x -> SBV a -> SBV b -> (SBool, [ProofStep z])) + where + inductionStrategy result steps = do + let predicate xs a b = result (Forall xs) (Forall a) (Forall b) + na = symbolVal (Proxy @na) + nb = symbolVal (Proxy @nb) + nxs = symbolVal (Proxy @nx) + nx = singular nxs + + x <- free nx + xs <- free nxs + a <- free na + b <- free nb + + let ih = internalAxiom "IH" $ \a' b' -> result (Forall xs) (a' :: Forall na a) (b' :: Forall nb b) + (intros, pSteps) = mkCalcSteps $ steps ih x xs a b + + pure InductionStrategy { + inductionIntros = intros + , inductionBaseCase = predicate SL.nil a b + , inductionProofSteps = pSteps + , inductionBaseFailureMsg = "Property fails for " ++ nxs ++ " = []." + , inductiveStep = observeIf not ("P(" ++ nx ++ ":" ++ nxs ++ ")") (predicate (x SL..: xs) a b) + } + +-- | Induction over 'SList' taking three extra arguments +instance forall na a nb b nc c nx x z. (KnownSymbol na, SymVal a, KnownSymbol nb, SymVal b, KnownSymbol nc, SymVal c, KnownSymbol nx, SymVal x, EqSymbolic z) + => Inductive (Forall nx [x] -> Forall na a -> Forall nb b -> Forall nc c -> SBool) + (SBV x -> SList x -> SBV a -> SBV b -> SBV c -> (SBool, [ProofStep z])) + where + inductionStrategy result steps = do + let predicate xs a b c = result (Forall xs) (Forall a) (Forall b) (Forall c) + na = symbolVal (Proxy @na) + nb = symbolVal (Proxy @nb) + nc = symbolVal (Proxy @nc) + nxs = symbolVal (Proxy @nx) + nx = singular nxs + + x <- free nx + xs <- free nxs + a <- free na + b <- free nb + c <- free nc + + let ih = internalAxiom "IH" $ \a' b' c' -> result (Forall xs) (a' :: Forall na a) (b' :: Forall nb b) (c' :: Forall nc c) + (intros, pSteps) = mkCalcSteps $ steps ih x xs a b c + + pure InductionStrategy { + inductionIntros = intros + , inductionBaseCase = predicate SL.nil a b c + , inductionProofSteps = pSteps + , inductionBaseFailureMsg = "Property fails for " ++ nxs ++ " = []." + , inductiveStep = observeIf not ("P(" ++ nx ++ ":" ++ nxs ++ ")") (predicate (x SL..: xs) a b c) + } + +-- | Induction over 'SList' taking four extra arguments +instance forall na a nb b nc c nd d nx x z. (KnownSymbol na, SymVal a, KnownSymbol nb, SymVal b, KnownSymbol nc, SymVal c, KnownSymbol nd, SymVal d, KnownSymbol nx, SymVal x, EqSymbolic z) + => Inductive (Forall nx [x] -> Forall na a -> Forall nb b -> Forall nc c -> Forall nd d -> SBool) + (SBV x -> SList x -> SBV a -> SBV b -> SBV c -> SBV d -> (SBool, [ProofStep z])) + where + inductionStrategy result steps = do + let predicate xs a b c d = result (Forall xs) (Forall a) (Forall b) (Forall c) (Forall d) + na = symbolVal (Proxy @na) + nb = symbolVal (Proxy @nb) + nc = symbolVal (Proxy @nc) + nd = symbolVal (Proxy @nd) + nxs = symbolVal (Proxy @nx) + nx = singular nxs + + x <- free nx + xs <- free nxs + a <- free na + b <- free nb + c <- free nc + d <- free nd + + let ih = internalAxiom "IH" $ \a' b' c' d' -> result (Forall xs) (a' :: Forall na a) (b' :: Forall nb b) (c' :: Forall nc c) (d' :: Forall nd d) + (intros, pSteps) = mkCalcSteps $ steps ih x xs a b c d + + pure InductionStrategy { + inductionIntros = intros + , inductionBaseCase = predicate SL.nil a b c d + , inductionProofSteps = pSteps + , inductionBaseFailureMsg = "Property fails for " ++ nxs ++ " = []." + , inductiveStep = observeIf not ("P(" ++ nx ++ ":" ++ nxs ++ ")") (predicate (x SL..: xs) a b c d) + } + +-- | Induction over 'SList' taking five extra arguments +instance forall na a nb b nc c nd d ne e nx x z. (KnownSymbol na, SymVal a, KnownSymbol nb, SymVal b, KnownSymbol nc, SymVal c, KnownSymbol nd, SymVal d, KnownSymbol ne, SymVal e, KnownSymbol nx, SymVal x, EqSymbolic z) + => Inductive (Forall nx [x] -> Forall na a -> Forall nb b -> Forall nc c -> Forall nd d -> Forall ne e -> SBool) + (SBV x -> SList x -> SBV a -> SBV b -> SBV c -> SBV d -> SBV e -> (SBool, [ProofStep z])) + where + inductionStrategy result steps = do + let predicate xs a b c d e = result (Forall xs) (Forall a) (Forall b) (Forall c) (Forall d) (Forall e) + na = symbolVal (Proxy @na) + nb = symbolVal (Proxy @nb) + nc = symbolVal (Proxy @nc) + nd = symbolVal (Proxy @nd) + ne = symbolVal (Proxy @ne) + nxs = symbolVal (Proxy @nx) + nx = singular nxs + + x <- free nx + xs <- free nxs + a <- free na + b <- free nb + c <- free nc + d <- free nd + e <- free ne + + let ih = internalAxiom "IH" $ \a' b' c' d' e' -> result (Forall xs) (a' :: Forall na a) (b' :: Forall nb b) (c' :: Forall nc c) (d' :: Forall nd d) (e' :: Forall ne e) + (intros, pSteps) = mkCalcSteps $ steps ih x xs a b c d e + + pure InductionStrategy { + inductionIntros = intros + , inductionBaseCase = predicate SL.nil a b c d e + , inductionProofSteps = pSteps + , inductionBaseFailureMsg = "Property fails for " ++ nxs ++ " = []." + , inductiveStep = observeIf not ("P(" ++ nx ++ ":" ++ nxs ++ ")") (predicate (x SL..: xs) a b c d e) + } + +-- | Instantiation for a universally quantified variable +newtype Inst (nm :: Symbol) a = Inst (SBV a) + +instance KnownSymbol nm => Show (Inst nm a) where + show (Inst a) = symbolVal (Proxy @nm) ++ " |-> " ++ show a + +-- | Instantiating a proof at different types of arguments. This is necessarily done using +-- dynamics, hand has a cost of not being applicable. +class Instantiatable a where + -- | Apply a universal proof to some arguments, creating an instance of the proof itself. + at :: Proof -> a -> Proof + +-- | Single parameter +instance (KnownSymbol na, HasKind a, Typeable a) => Instantiatable (Inst na a) where + at = instantiate $ \f (Inst a) -> f (Forall a :: Forall na a) + +-- | Two parameters +instance ( KnownSymbol na, HasKind a, Typeable a + , KnownSymbol nb, HasKind b, Typeable b + ) => Instantiatable (Inst na a, Inst nb b) where + at = instantiate $ \f (Inst a, Inst b) -> f (Forall a :: Forall na a) (Forall b :: Forall nb b) + +-- | Three parameters +instance ( KnownSymbol na, HasKind a, Typeable a + , KnownSymbol nb, HasKind b, Typeable b + , KnownSymbol nc, HasKind c, Typeable c + ) => Instantiatable (Inst na a, Inst nb b, Inst nc c) where + at = instantiate $ \f (Inst a, Inst b, Inst c) -> f (Forall a :: Forall na a) (Forall b :: Forall nb b) (Forall c :: Forall nc c) + +-- | Four parameters +instance ( KnownSymbol na, HasKind a, Typeable a + , KnownSymbol nb, HasKind b, Typeable b + , KnownSymbol nc, HasKind c, Typeable c + , KnownSymbol nd, HasKind d, Typeable d + ) => Instantiatable (Inst na a, Inst nb b, Inst nc c, Inst nd d) where + at = instantiate $ \f (Inst a, Inst b, Inst c, Inst d) -> f (Forall a :: Forall na a) (Forall b :: Forall nb b) (Forall c :: Forall nc c) (Forall d :: Forall nd d) + +-- | Five parameters +instance ( KnownSymbol na, HasKind a, Typeable a + , KnownSymbol nb, HasKind b, Typeable b + , KnownSymbol nc, HasKind c, Typeable c + , KnownSymbol nd, HasKind d, Typeable d + , KnownSymbol ne, HasKind e, Typeable e + ) => Instantiatable (Inst na a, Inst nb b, Inst nc c, Inst nd d, Inst ne e) where + at = instantiate $ \f (Inst a, Inst b, Inst c, Inst d, Inst e) -> f (Forall a :: Forall na a) (Forall b :: Forall nb b) (Forall c :: Forall nc c) (Forall d :: Forall nd d) (Forall e :: Forall ne e) + +instantiate :: (Typeable f, Show arg) => (f -> arg -> SBool) -> Proof -> arg -> Proof +instantiate ap p@Proof{getProp, proofName} a = case fromDynamic getProp of + Nothing -> cantInstantiate + Just f -> let result = f `ap` a + nm = proofName ++ " @ " ++ paren sha + in p { getProof = label nm result + , getProp = toDyn result + , proofName = nm + } + where sha = show a + cantInstantiate = error $ unlines [ "at: Cannot instantiate proof:" + , " Name: " ++ proofName + , " Type: " ++ trim (show getProp) + , " At : " ++ sha + ] + + -- dynamic puts funky <> at the beginning and end; trim it: + trim ('<':'<':s) = reverse (trimE (reverse s)) + trim s = s + trimE ('>':'>':s) = s + trimE s = s + + -- Add parens if necessary + paren s | "(" `isPrefixOf` s && ")" `isSuffixOf` s = s + | not (any isSpace s) = s + | True = '(' : s ++ ")" + +-- | Helpers for a step +data Helper = HProof Proof -- A previously proven theorem + | HAssum SBool -- A hypothesis + +-- | Smart constructor for creating a helper from a boolean. This is hardly needed, unless you're +-- mixing proofs and booleans in one group of hints. +hyp :: SBool -> Helper +hyp = HAssum + +-- | Smart constructor for creating a helper from a boolean. This is hardly needed, unless you're +-- mixing proofs and booleans in one group of hints. +hprf :: Proof -> Helper +hprf = HProof + +-- | Get the underlying boolean of a helper +getHelperBool :: Helper -> SBool +getHelperBool (HProof p) = getProof p +getHelperBool (HAssum b) = b + +-- | A proof-step with associated helpers +data ProofStep a = ProofStep a [Helper] + +-- | Class capturing giving a proof-step helper +class ProofHint a b where + -- | Specify a helper for the given proof step + (?) :: a -> b -> ProofStep a + infixl 2 ? + +-- | Giving just one proof as a helper. +instance ProofHint a Proof where + a ? p = ProofStep a [HProof p] + +-- | Giving just one boolean as a helper. +instance ProofHint a SBool where + a ? p = ProofStep a [HAssum p] + +-- | Giving just one helper +instance ProofHint a Helper where + a ? h = ProofStep a [h] + +-- | Giving a bunch of proofs as a helper. +instance ProofHint a [Proof] where + a ? ps = ProofStep a (map HProof ps) + +-- | Giving a bunch of booleans as a helper. +instance ProofHint a [SBool] where + a ? ps = ProofStep a (map HAssum ps) + +-- | Giving a set of helpers +instance ProofHint a [Helper] where + a ? hs = ProofStep a hs + +-- | Capture what a given step can chain-to. This is a closed-type family, i.e., +-- we don't allow users to change this and write other chainable things. Probably it is not really necessary, +-- but we'll cross that bridge if someone actually asks for it. +type family ChainsTo a where + ChainsTo (ProofStep a) = [ProofStep a] + ChainsTo a = [ProofStep a] + +-- | Chain steps in a calculational proof. +(=:) :: ChainStep a (ChainsTo a) => a -> ChainsTo a -> ChainsTo a +(=:) = chain +infixr 1 =: + +-- | Unicode alternative for `=:`: +(≡) :: ChainStep a (ChainsTo a) => a -> ChainsTo a -> ChainsTo a +(≡) = (=:) +infixr 1 ≡ + +-- | Chaining two steps together +class ChainStep a b where + chain :: a -> b -> b + +-- | Chaining from a value without any annotation +instance ChainStep a [ProofStep a] where + chain x y = ProofStep x [] : y + +-- | Chaining from another proof step +instance ChainStep (ProofStep a) [ProofStep a] where + chain x y = x : y + +-- | Mark the end of a calculational proof. +qed :: [ProofStep a] +qed = [] + +-- | Start a calculational proof, with the given hypothesis. Use @[]@ as the +-- first argument if the calculation holds unconditionally. The first argument is +-- typically used to introduce hypotheses in proofs of implications such as @A .=> B .=> C@, where +-- we would put @[A, B]@ as the starting assumption. You can name these and later use in the derivation steps. +(|-) :: [SBool] -> [ProofStep a] -> (SBool, [ProofStep a]) +bs |- ps = (sAnd bs, ps) +infixl 0 |- + +-- | Alternative unicode for `|-`: +(⊢) :: [SBool] -> [ProofStep a] -> (SBool, [ProofStep a]) +(⊢) = (|-) +infixl 0 ⊢ diff --git a/Data/SBV/Tools/KD/Utils.hs b/Data/SBV/Tools/KD/Utils.hs new file mode 100644 --- /dev/null +++ b/Data/SBV/Tools/KD/Utils.hs @@ -0,0 +1,167 @@ +----------------------------------------------------------------------------- +-- | +-- Module : Data.SBV.Tools.KD.Utils +-- Copyright : (c) Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Various KnuckleDrugger machinery. +----------------------------------------------------------------------------- + +{-# LANGUAGE DeriveAnyClass #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE DerivingStrategies #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE NamedFieldPuns #-} + +{-# OPTIONS_GHC -Wall -Werror #-} + +module Data.SBV.Tools.KD.Utils ( + KD, runKD, runKDWith, Proof(..) + , startKD, finishKD, getKDState, getKDConfig, KDState(..), KDStats(..) + , RootOfTrust(..), calculateRootOfTrust, message, updStats + ) where + +import Control.Monad.Reader (ReaderT, runReaderT, MonadReader, ask, liftIO) +import Control.Monad.Trans (MonadIO) + +import Data.Time (NominalDiffTime) + +import Data.List (intercalate, nub, sort) +import System.IO (hFlush, stdout) + +import Data.SBV.Core.Data (SBool) +import Data.SBV.Core.Symbolic (SMTConfig, KDOptions(..)) +import Data.SBV.Provers.Prover (defaultSMTCfg, SMTConfig(..)) + +import Data.SBV.Utils.TDiff (showTDiff, timeIf) +import Control.DeepSeq (NFData(rnf)) + +import Data.IORef + +import GHC.Generics +import Data.Dynamic + +-- | Various statistics we collect +data KDStats = KDStats { noOfCheckSats :: Int + , solverElapsed :: NominalDiffTime + } + +-- | Extra state we carry in a KD context +data KDState = KDState { stats :: IORef KDStats + , config :: SMTConfig + } + +-- | Monad for running KnuckleDragger proofs in. +newtype KD a = KD (ReaderT KDState IO a) + deriving newtype (Applicative, Functor, Monad, MonadIO, MonadReader KDState, MonadFail) + +-- | Run a KD proof, using the default configuration. +runKD :: KD a -> IO a +runKD = runKDWith defaultSMTCfg + +-- | Run a KD proof, using the given configuration. +runKDWith :: SMTConfig -> KD a -> IO a +runKDWith cfg@SMTConfig{kdOptions = KDOptions{measureTime}} (KD f) = do + rStats <- newIORef $ KDStats { noOfCheckSats = 0, solverElapsed = 0 } + (mbT, r) <- timeIf measureTime $ runReaderT f KDState {config = cfg, stats = rStats} + case mbT of + Nothing -> pure () + Just t -> do KDStats noOfCheckSats solverTime <- readIORef rStats + + let stats = [ ("SBV", showTDiff (t - solverTime)) + , ("Solver", showTDiff solverTime) + , ("Total", showTDiff t) + , ("Decisions", show noOfCheckSats) + ] + + message cfg $ '[' : intercalate ", " [k ++ ": " ++ v | (k, v) <- stats] ++ "]\n" + pure r + +-- | get the state +getKDState :: KD KDState +getKDState = ask + +-- | get the configuration +getKDConfig :: KD SMTConfig +getKDConfig = config <$> getKDState + +-- | Update stats +updStats :: MonadIO m => KDState -> (KDStats -> KDStats) -> m () +updStats KDState{stats} u = liftIO $ modifyIORef' stats u + +-- | Display the message if not quiet. Note that we don't print a newline; so the message must have it if needed. +message :: MonadIO m => SMTConfig -> String -> m () +message SMTConfig{kdOptions = KDOptions{quiet}} s + | quiet = pure () + | True = liftIO $ putStr s + +-- | Start a proof. We return the number of characters we printed, so the finisher can align the result. +startKD :: SMTConfig -> Bool -> String -> [String] -> IO Int +startKD cfg newLine what nms = do message cfg $ line ++ if newLine then "\n" else "" + hFlush stdout + return (length line) + where tab = 2 * length (drop 1 nms) + indent = replicate tab ' ' + tag = what ++ ": " ++ intercalate "." (filter (not . null) nms) + line = indent ++ tag + +-- | Finish a proof. First argument is what we got from the call of 'startKD' above. +finishKD :: SMTConfig -> String -> (Int, Maybe NominalDiffTime) -> [NominalDiffTime] -> IO () +finishKD cfg@SMTConfig{kdOptions = KDOptions{ribbonLength}} what (skip, mbT) extraTiming = + message cfg $ replicate (ribbonLength - skip) ' ' ++ what ++ timing ++ extras ++ "\n" + where timing = maybe "" ((' ' :) . mkTiming) mbT + extras = concatMap mkTiming extraTiming + + mkTiming t = '[' : showTDiff t ++ "]" + +-- | Keeping track of where the sorry originates from. Used in displaying dependencies. +data RootOfTrust = None -- ^ Trusts nothing (aside from SBV, underlying solver etc.) + | Self -- ^ Trusts itself, i.e., established by a call to sorry + | Prop String -- ^ Trusts a parent that itself trusts something else. Note the name here is the + -- name of the proposition itself, not the parent that's trusted. + deriving (NFData, Generic) + +-- | Proof for a property. This type is left abstract, i.e., the only way to create on is via a +-- call to lemma/theorem etc., ensuring soundness. (Note that the trusted-code base here +-- is still large: The underlying solver, SBV, and KnuckleDragger kernel itself. But this +-- mechanism ensures we can't create proven things out of thin air, following the standard LCF +-- methodology.) +data Proof = Proof { rootOfTrust :: RootOfTrust -- ^ Root of trust, described above. + , isUserAxiom :: Bool -- ^ Was this an axiom given by the user? + , getProof :: SBool -- ^ Get the underlying boolean + , getProp :: Dynamic -- ^ The actual proposition + , proofName :: String -- ^ User given name + } + +-- | NFData ignores the getProp field +instance NFData Proof where + rnf (Proof rootOfTrust isUserAxiom getProof _getProp proofName) = rnf rootOfTrust + `seq` rnf isUserAxiom + `seq` rnf getProof + `seq` rnf proofName + +-- | Show instance for 'Proof' +instance Show Proof where + show Proof{rootOfTrust, isUserAxiom, proofName} = '[' : tag ++ "] " ++ proofName + where tag | isUserAxiom = "Axiom" + | True = case rootOfTrust of + None -> "Proven" + Self -> "Sorry" + Prop s -> "Modulo: " ++ s + +-- | Calculate the root of trust for a proof. The string is the modulo text, if any. +calculateRootOfTrust :: String -> [Proof] -> (RootOfTrust, String) +calculateRootOfTrust nm by | not hasSelf && null depNames = (None, "") + | True = (Prop nm, " [Modulo: " ++ why ++ "]") + where why | hasSelf = "sorry" + | True = intercalate ", " depNames + + -- What's the root-of-trust for this node? + -- If there are no "sorry" parents, and no parent nodes + -- that are marked with a root of trust, then we don't have it either. + -- Otherwise, mark it accordingly. + parentRoots = map rootOfTrust by + hasSelf = not $ null [() | Self <- parentRoots] + depNames = nub $ sort [p | Prop p <- parentRoots] diff --git a/Data/SBV/Tools/KDKernel.hs b/Data/SBV/Tools/KDKernel.hs deleted file mode 100644 --- a/Data/SBV/Tools/KDKernel.hs +++ /dev/null @@ -1,307 +0,0 @@ ------------------------------------------------------------------------------ --- | --- Module : Data.SBV.Tools.KDKernel --- Copyright : (c) Levent Erkok --- License : BSD3 --- Maintainer: erkokl@gmail.com --- Stability : experimental --- --- Kernel of the KnuckleDragger prover API. ------------------------------------------------------------------------------ - -{-# LANGUAGE ConstraintKinds #-} -{-# LANGUAGE FlexibleContexts #-} -{-# LANGUAGE FlexibleInstances #-} -{-# LANGUAGE NamedFieldPuns #-} -{-# LANGUAGE ScopedTypeVariables #-} - -{-# OPTIONS_GHC -Wall -Werror #-} - -module Data.SBV.Tools.KDKernel ( - Proposition, Proof - , axiom - , lemma, lemmaWith, lemmaGen - , theorem, theoremWith - , Induction(..) - , sorry - ) where - -import Control.Monad.Trans (liftIO) -import Control.Monad.Reader (ask) - -import Data.List (intercalate, sort, nub) - -import Data.SBV -import Data.SBV.Core.Data (Constraint) - -import Data.SBV.Tools.KDUtils - -import qualified Data.SBV.List as SL - --- | A proposition is something SBV is capable of proving/disproving. We capture this --- with a set of constraints. This type might look scary, but for the most part you --- can ignore it and treat it as anything you can pass to 'prove' or 'sat' in SBV. -type Proposition a = ( QuantifiedBool a - , QNot a - , Skolemize (NegatesTo a) - , Satisfiable (Symbolic (SkolemsTo (NegatesTo a))) - , Constraint Symbolic (SkolemsTo (NegatesTo a)) - ) - --- | Keeping track of where the sorry originates from. Used in displaying dependencies. -data RootOfTrust = None -- ^ Trusts nothing (aside from SBV, underlying solver etc.) - | Self -- ^ Trusts itself, i.e., established by a call to sorry - | Prop String -- ^ Trusts a parent that itself trusts something else. Note the name here is the - -- name of the proposition itself, not the parent that's trusted. - --- | Proof for a property. This type is left abstract, i.e., the only way to create on is via a --- call to 'lemma'/'theorem' etc., ensuring soundness. (Note that the trusted-code base here --- is still large: The underlying solver, SBV, and KnuckleDragger kernel itself. But this --- mechanism ensures we can't create proven things out of thin air, following the standard LCF --- methodology.) -data Proof = Proof { rootOfTrust :: RootOfTrust -- ^ Root of trust, described above. - , isUserAxiom :: Bool -- ^ Was this an axiom given by the user? - , getProof :: SBool -- ^ Get the underlying boolean - , proofName :: String -- ^ User given name - } - --- | Show instance for 'Proof' -instance Show Proof where - show Proof{rootOfTrust, isUserAxiom, proofName} = '[' : tag ++ "] " ++ proofName - where tag | isUserAxiom = "Axiom" - | True = case rootOfTrust of - None -> "Proven" - Self -> "Sorry" - Prop s -> "Modulo: " ++ s - --- | Accept the given definition as a fact. Usually used to introduce definitial axioms, --- giving meaning to uninterpreted symbols. Note that we perform no checks on these propositions, --- if you assert nonsense, then you get nonsense back. So, calls to 'axiom' should be limited to --- definitions, or basic axioms (like commutativity, associativity) of uninterpreted function symbols. -axiom :: Proposition a => String -> a -> KD Proof -axiom nm p = do start False "Axiom" [nm] >>= finish "Axiom." - - pure (internalAxiom nm p) { isUserAxiom = True } - --- | Internal axiom generator; so we can keep truck of KnuckleDrugger's trusted axioms, vs. user given axioms. --- Not exported. -internalAxiom :: Proposition a => String -> a -> Proof -internalAxiom nm p = Proof { rootOfTrust = None - , isUserAxiom = False - , getProof = label nm (quantifiedBool p) - , proofName = nm - } - --- | A manifestly false theorem. This is useful when we want to prove a theorem that the underlying solver --- cannot deal with, or if we want to postpone the proof for the time being. KnuckleDragger will keep --- track of the uses of 'sorry' and will print them appropriately while printing proofs. -sorry :: Proof -sorry = Proof { rootOfTrust = Self - , isUserAxiom = False - , getProof = label "sorry" (quantifiedBool p) - , proofName = "sorry" - } - where -- ideally, I'd rather just use - -- p = sFalse - -- but then SBV constant folds the boolean, and the generated script - -- doesn't contain the actual contents, as SBV determines unsatisfiability - -- itself. By using the following proposition (which is easy for the backend - -- solver to determine as false, we avoid the constant folding. - p (Forall (x :: SBool)) = label "SORRY: KnuckleDragger, proof uses \"sorry\"" x - --- | Helper to generate lemma/theorem statements. -lemmaGen :: Proposition a => SMTConfig -> String -> [String] -> a -> [Proof] -> KD Proof -lemmaGen cfg@SMTConfig{verbose} what nms inputProp by = do - tab <- start verbose what nms - - let nm = intercalate "." nms - - -- What to do if all goes well - good = do finish ("Q.E.D." ++ modulo) tab - pure Proof { rootOfTrust = ros - , isUserAxiom = False - , getProof = label nm (quantifiedBool inputProp) - , proofName = nm - } - - where parentRoots = map rootOfTrust by - hasSelf = not $ null [() | Self <- parentRoots] - depNames = nub $ sort [p | Prop p <- parentRoots] - - -- What's the root-of-trust for this node? - -- If there are no "sorry" parents, and no parent nodes - -- that are marked with a root of trust, then we don't have it either. - -- Otherwise, mark it accordingly. - (ros, modulo) - | not hasSelf && null depNames = (None, "") - | True = (Prop nm, " [Modulo: " ++ why ++ "]") - where why | hasSelf = "sorry" - | True = intercalate ", " depNames - - -- What to do if the proof fails - cex = liftIO $ do putStrLn $ "\n*** Failed to prove " ++ nm ++ "." - - -- When trying to get a counter-example, only include in the - -- implication those facts that are user-given axioms. This - -- way our counter-example will be more likely to be relevant - -- to the proposition we're currently proving. (Hopefully.) - -- Remember that we first have to negate, and then skolemize! - SatResult res <- satWith cfg $ do - mapM_ constrain [getProof | Proof{isUserAxiom, getProof} <- by, isUserAxiom] :: Symbolic () - pure $ skolemize (qNot inputProp) - - print $ ThmResult res - error "Failed" - - -- bailing out - failed r = liftIO $ do putStrLn $ "\n*** Failed to prove " ++ nm ++ "." - print r - error "Failed" - - pRes <- liftIO $ proveWith cfg $ do - mapM_ (constrain . getProof) by :: Symbolic () - pure $ skolemize (quantifiedBool inputProp) - - case pRes of - ThmResult Unsatisfiable{} -> good - ThmResult Satisfiable{} -> cex - ThmResult DeltaSat{} -> cex - ThmResult SatExtField{} -> cex - ThmResult Unknown{} -> failed pRes - ThmResult ProofError{} -> failed pRes - --- | Prove a given statement, using auxiliaries as helpers. Using the default solver. -lemma :: Proposition a => String -> a -> [Proof] -> KD Proof -lemma nm f by = do cfg <- ask - lemmaWith cfg nm f by - --- | Prove a given statement, using auxiliaries as helpers. Using the given solver. -lemmaWith :: Proposition a => SMTConfig -> String -> a -> [Proof] -> KD Proof -lemmaWith cfg nm = lemmaGen cfg "Lemma" [nm] - --- | Prove a given statement, using auxiliaries as helpers. Essentially the same as 'lemma', except for the name, using the default solver. -theorem :: Proposition a => String -> a -> [Proof] -> KD Proof -theorem nm f by = do cfg <- ask - theoremWith cfg nm f by - --- | Prove a given statement, using auxiliaries as helpers. Essentially the same as 'lemmaWith', except for the name. -theoremWith :: Proposition a => SMTConfig -> String -> a -> [Proof] -> KD Proof -theoremWith cfg nm = lemmaGen cfg "Theorem" [nm] - --- | Given a predicate, return an induction principle for it. Typically, we only have one viable --- induction principle for a given type, but we allow for alternative ones. -class Induction a where - induct :: a -> Proof - inductAlt1 :: a -> Proof - inductAlt2 :: a -> Proof - - -- The second and third principles are the same as first by default, unless we provide them explicitly. - inductAlt1 = induct - inductAlt2 = induct - --- | Induction over SInteger. We provide various induction principles here: The first one --- is over naturals, will only prove predicates that explicitly restrict the argument to >= 0. --- The second and third ones are induction over the entire range of integers, two different --- principles that might work better for different problems. -instance Induction (SInteger -> SBool) where - - -- | Induction over naturals. Will prove predicates of the form @\n -> n >= 0 .=> predicate n@. - induct p = internalAxiom "Nat.induct" principle - where qb = quantifiedBool - - principle = p 0 .&& qb (\(Forall n) -> (n .>= 0 .&& p n) .=> p (n+1)) - .=> qb ----------------------------------------------------------- - (\(Forall n) -> n .>= 0 .=> p n) - - - -- | Induction over integers, using the strategy that @P(n)@ is equivalent to @P(n+1)@ - -- (i.e., not just @P(n) => P(n+1)@), thus covering the entire range. - inductAlt1 p = internalAxiom "Integer.inductAlt1" principle - where qb = quantifiedBool - - principle = p 0 - .&& qb (\(Forall i) -> p i .== p (i+1)) - .=> qb ----------------------------------------- - (\(Forall i) -> p i) - - -- | Induction over integers, using the strategy that @P(n) => P(n+1)@ and @P(n) => P(n-1)@. - inductAlt2 p = internalAxiom "Integer.inductAlt2" principle - where qb = quantifiedBool - - principle = p 0 - .&& qb (\(Forall i) -> p i .=> p (i+1) .&& p (i-1)) - .=> qb ----------------------------------------------------- - (\(Forall i) -> p i) - --- | Induction over two argument predicates, with the last argument SInteger. -instance SymVal a => Induction (SBV a -> SInteger -> SBool) where - induct p = internalAxiom "Nat.induct2" principle - where qb a = quantifiedBool a - - principle = qb (\(Forall a) -> p a 0) - .&& qb (\(Forall a) (Forall n) -> (n .>= 0 .&& p a n) .=> p a (n+1)) - .=> qb ---------------------------------------------------------------------- - (\(Forall a) (Forall n) -> n .>= 0 .=> p a n) - --- | Induction over three argument predicates, with last argument SInteger. -instance (SymVal a, SymVal b) => Induction (SBV a -> SBV b -> SInteger -> SBool) where - induct p = internalAxiom "Nat.induct3" principle - where qb a = quantifiedBool a - - principle = qb (\(Forall a) (Forall b) -> p a b 0) - .&& qb (\(Forall a) (Forall b) (Forall n) -> (n .>= 0 .&& p a b n) .=> p a b (n+1)) - .=> qb ------------------------------------------------------------------------------------- - (\(Forall a) (Forall b) (Forall n) -> n .>= 0 .=> p a b n) - --- | Induction over four argument predicates, with last argument SInteger. -instance (SymVal a, SymVal b, SymVal c) => Induction (SBV a -> SBV b -> SBV c -> SInteger -> SBool) where - induct p = internalAxiom "Nat.induct4" principle - where qb a = quantifiedBool a - - principle = qb (\(Forall a) (Forall b) (Forall c) -> p a b c 0) - .&& qb (\(Forall a) (Forall b) (Forall c) (Forall n) -> (n .>= 0 .&& p a b c n) .=> p a b c (n+1)) - .=> qb ---------------------------------------------------------------------------------------------------- - (\(Forall a) (Forall b) (Forall c) (Forall n) -> n .>= 0 .=> p a b c n) - - --- | Induction over lists -instance SymVal a => Induction (SList a -> SBool) where - induct p = internalAxiom "List(a).induct" principle - where qb a = quantifiedBool a - - principle = p SL.nil - .&& qb (\(Forall x) (Forall xs) -> p xs .=> p (x SL..: xs)) - .=> qb ------------------------------------------------------------- - (\(Forall xs) -> p xs) - --- | Induction over two argument predicates, with last argument a list. -instance (SymVal a, SymVal e) => Induction (SBV a -> SList e -> SBool) where - induct p = internalAxiom "List(a).induct2" principle - where qb a = quantifiedBool a - - principle = qb (\(Forall a) -> p a SL.nil) - .&& qb (\(Forall a) (Forall e) (Forall es) -> p a es .=> p a (e SL..: es)) - .=> qb ------------------------------------------------------------------------------ - (\(Forall a) (Forall es) -> p a es) - --- | Induction over three argument predicates, with last argument a list. -instance (SymVal a, SymVal b, SymVal e) => Induction (SBV a -> SBV b -> SList e -> SBool) where - induct p = internalAxiom "List(a).induct3" principle - where qb a = quantifiedBool a - - principle = qb (\(Forall a) (Forall b) -> p a b SL.nil) - .&& qb (\(Forall a) (Forall b) (Forall e) (Forall es) -> p a b es .=> p a b (e SL..: es)) - .=> qb ------------------------------------------------------------------------------------------- - (\(Forall a) (Forall b) (Forall xs) -> p a b xs) - --- | Induction over four argument predicates, with last argument a list. -instance (SymVal a, SymVal b, SymVal c, SymVal e) => Induction (SBV a -> SBV b -> SBV c -> SList e -> SBool) where - induct p = internalAxiom "List(a).induct4" principle - where qb a = quantifiedBool a - - principle = qb (\(Forall a) (Forall b) (Forall c) -> p a b c SL.nil) - .&& qb (\(Forall a) (Forall b) (Forall c) (Forall e) (Forall es) -> p a b c es .=> p a b c (e SL..: es)) - .=> qb ---------------------------------------------------------------------------------------------------------- - (\(Forall a) (Forall b) (Forall c) (Forall xs) -> p a b c xs) - -{- HLint ignore module "Eta reduce" -} diff --git a/Data/SBV/Tools/KDUtils.hs b/Data/SBV/Tools/KDUtils.hs deleted file mode 100644 --- a/Data/SBV/Tools/KDUtils.hs +++ /dev/null @@ -1,57 +0,0 @@ ------------------------------------------------------------------------------ --- | --- Module : Data.SBV.Tools.KDUtils --- Copyright : (c) Levent Erkok --- License : BSD3 --- Maintainer: erkokl@gmail.com --- Stability : experimental --- --- Various KnuckleDrugger machinery. ------------------------------------------------------------------------------ - -{-# LANGUAGE DerivingStrategies #-} -{-# LANGUAGE GeneralizedNewtypeDeriving #-} -{-# LANGUAGE NamedFieldPuns #-} - -{-# OPTIONS_GHC -Wall -Werror #-} - -module Data.SBV.Tools.KDUtils ( - KD, runKD, runKDWith - , start, finish - ) where - -import Control.Monad.Reader (ReaderT, runReaderT, ask, MonadReader) -import Control.Monad.Trans (MonadIO(liftIO)) - -import Data.List (intercalate) -import System.IO (hFlush, stdout) - -import Data.SBV.Core.Symbolic (SMTConfig) -import Data.SBV.Provers.Prover (defaultSMTCfg, SMTConfig(..)) - --- | Monad for running KnuckleDragger proofs in. -newtype KD a = KD (ReaderT SMTConfig IO a) - deriving newtype (Applicative, Functor, Monad, MonadIO, MonadReader SMTConfig, MonadFail) - --- | Run a KD proof, using the default configuration. -runKD :: KD a -> IO a -runKD = runKDWith defaultSMTCfg - --- | Run a KD proof, using the given configuration. -runKDWith :: SMTConfig -> KD a -> IO a -runKDWith cfg (KD f) = runReaderT f cfg - --- | Start a proof. We return the number of characters we printed, so the finisher can align the result. -start :: Bool -> String -> [String] -> KD Int -start newLine what nms = liftIO $ do putStr $ line ++ if newLine then "\n" else "" - hFlush stdout - return (length line) - where tab = 2 * length (drop 1 nms) - indent = replicate tab ' ' - tag = what ++ ": " ++ intercalate "." nms - line = indent ++ tag - --- | Finish a proof. First argument is what we got from the call of 'start' above. -finish :: String -> Int -> KD () -finish what skip = do SMTConfig{kdRibbonLength} <- ask - liftIO $ putStrLn $ replicate (kdRibbonLength - skip) ' ' ++ what diff --git a/Data/SBV/Tools/KnuckleDragger.hs b/Data/SBV/Tools/KnuckleDragger.hs --- a/Data/SBV/Tools/KnuckleDragger.hs +++ b/Data/SBV/Tools/KnuckleDragger.hs @@ -13,163 +13,47 @@ -- See the directory Documentation.SBV.Examples.KnuckleDragger for various examples. ----------------------------------------------------------------------------- -{-# LANGUAGE ConstraintKinds #-} -{-# LANGUAGE DataKinds #-} -{-# LANGUAGE DerivingStrategies #-} -{-# LANGUAGE FlexibleContexts #-} -{-# LANGUAGE FlexibleInstances #-} -{-# LANGUAGE FunctionalDependencies #-} -{-# LANGUAGE GeneralizedNewtypeDeriving #-} -{-# LANGUAGE MultiParamTypeClasses #-} -{-# LANGUAGE NamedFieldPuns #-} -{-# LANGUAGE TypeAbstractions #-} - {-# OPTIONS_GHC -Wall -Werror #-} module Data.SBV.Tools.KnuckleDragger ( -- * Propositions and their proofs Proposition, Proof + -- * Adding axioms/definitions , axiom - -- * Basic proofs - , lemma, lemmaWith - , theorem, theoremWith - -- * Chain of reasoning - , chainLemma, chainLemmaWith - , chainTheorem, chainTheoremWith - -- * Induction - , Induction(..) - -- * Faking proofs - , sorry - -- * Running KnuckleDragger proofs - , KD, runKD, runKDWith - ) where -import Control.Monad.Trans (liftIO) - -import Data.SBV -import Data.SBV.Tools.KDKernel -import Data.SBV.Tools.KDUtils - -import Control.Monad (when) -import Control.Monad.Reader (ask) - --- | A class for doing equational reasoning style chained proofs. Use 'chainLemma' to prove a given theorem --- as a sequence of equalities, each step following from the previous. -class ChainLemma steps step | steps -> step where - - -- | Prove a property via a series of equality steps, using the default solver. - -- Let @H@ be a list of already established lemmas. Let @P@ be a property we wanted to prove, named @name@. - -- Consider a call of the form @chainLemma name P [A, B, C, D] H@. Note that @H@ is - -- a list of already proven facts, ensured by the type signature. We proceed as follows: - -- - -- * Prove: @H -> A == B@ - -- * Prove: @H && A == B -> B == C@ - -- * Prove: @H && A == B && B == C -> C == D@ - -- * Prove: @H && A == B && B == C && C == D -> P@ - -- * If all of the above steps succeed, conclude @P@. - -- - -- Note that if the type of steps (i.e., @A@ .. @D@ above) is 'SBool', then we use implication - -- as opposed to equality; which better captures line of reasoning. - -- - -- So, chain-lemma is essentially modus-ponens, applied in a sequence of stepwise equality reasoning in the case of - -- non-boolean steps. - -- - -- If there are no helpers given (i.e., if @H@ is empty), then this call is equivalent to 'lemmaWith'. - -- If @H@ is a singleton, then we error-out. A single step in @H@ indicates a user-error, since there's - -- no sequence of steps to reason about. - chainLemma :: Proposition a => String -> a -> steps -> [Proof] -> KD Proof - - -- | Same as chainLemma, except tagged as Theorem - chainTheorem :: Proposition a => String -> a -> steps -> [Proof] -> KD Proof - - -- | Prove a property via a series of equality steps, using the given solver. - chainLemmaWith :: Proposition a => SMTConfig -> String -> a -> steps -> [Proof] -> KD Proof - - -- | Same as chainLemmaWith, except tagged as Theorem - chainTheoremWith :: Proposition a => SMTConfig -> String -> a -> steps -> [Proof] -> KD Proof - - -- | Internal, shouldn't be needed outside the library - makeSteps :: steps -> [step] - makeInter :: steps -> step -> step -> SBool - - chainLemma nm p steps by = do cfg <- ask - chainLemmaWith cfg nm p steps by - - chainTheorem nm p steps by = do cfg <- ask - chainTheoremWith cfg nm p steps by - - chainLemmaWith = chainGeneric False - chainTheoremWith = chainGeneric True - - chainGeneric :: Proposition a => Bool -> SMTConfig -> String -> a -> steps -> [Proof] -> KD Proof - chainGeneric taggedTheorem cfg nm result steps base = do - liftIO $ putStrLn $ "Chain: " ++ nm - let proofSteps = makeSteps steps - len = length proofSteps - - when (len == 1) $ - error $ unlines $ [ "Incorrect use of chainLemma on " ++ show nm ++ ":" - , "** There must be either none, or at least two steps." - , "** Was given only one step." - ] - - go (1 :: Int) base (zipWith (makeInter steps) proofSteps (drop 1 proofSteps)) - - where go _ sofar [] - | taggedTheorem = theoremWith cfg nm result sofar - | True = lemmaWith cfg nm result sofar - go i sofar (p:ps) - | True - = do step <- lemmaGen cfg "Lemma" ([nm, show i]) p sofar - go (i+1) (step : sofar) ps + -- * Basic proofs + , lemma, lemmaWith + , theorem, theoremWith --- | Chaining lemmas that depend on a single quantified variable. -instance (SymVal a, EqSymbolic z) => ChainLemma (SBV a -> [z]) (SBV a -> z) where - makeSteps steps = [\a -> steps a !! i | i <- [0 .. length (steps undefined) - 1]] - makeInter _ x y = quantifiedBool $ \(Forall @"a" a) -> x a .== y a + -- * Reasoning via calculation + , calc, calcWith + , calcThm, calcThmWith --- | Chaining lemmas that depend on two quantified variables. -instance (SymVal a, SymVal b, EqSymbolic z) => ChainLemma (SBV a -> SBV b -> [z]) (SBV a -> SBV b -> z) where - makeSteps steps = [\a b -> steps a b !! i | i <- [0 .. length (steps undefined undefined) - 1]] - makeInter _ x y = quantifiedBool $ \(Forall @"a" a) (Forall @"b" b) -> x a b .== y a b + -- * Reasoning via induction + , induct, inductWith + , inductThm, inductThmWith --- | Chaining lemmas that depend on three quantified variables. -instance (SymVal a, SymVal b, SymVal c, EqSymbolic z) => ChainLemma (SBV a -> SBV b -> SBV c -> [z]) (SBV a -> SBV b -> SBV c -> z) where - makeSteps steps = [\a b c -> steps a b c !! i | i <- [0 .. length (steps undefined undefined undefined) - 1]] - makeInter _ x y = quantifiedBool $ \(Forall @"a" a) (Forall @"b" b) (Forall @"c" c) -> x a b c .== y a b c + -- * Creating instances of proofs + , at, Inst(..) --- | Chaining lemmas that depend on four quantified variables. -instance (SymVal a, SymVal b, SymVal c, SymVal d, EqSymbolic z) => ChainLemma (SBV a -> SBV b -> SBV c -> SBV d -> [z]) (SBV a -> SBV b -> SBV c -> SBV d -> z) where - makeSteps steps = [\a b c d -> steps a b c d !! i | i <- [0 .. length (steps undefined undefined undefined undefined) - 1]] - makeInter _ x y = quantifiedBool $ \(Forall @"a" a) (Forall @"b" b) (Forall @"c" c) (Forall @"d" d) -> x a b c d .== y a b c d + -- * Faking proofs + , sorry --- | Chaining lemmas that depend on five quantified variables. -instance (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, EqSymbolic z) => ChainLemma (SBV a -> SBV b -> SBV c -> SBV d -> SBV e -> [z]) (SBV a -> SBV b -> SBV c -> SBV d -> SBV e -> z) where - makeSteps steps = [\a b c d e -> steps a b c d e !! i | i <- [0 .. length (steps undefined undefined undefined undefined undefined) - 1]] - makeInter _ x y = quantifiedBool $ \(Forall @"a" a) (Forall @"b" b) (Forall @"c" c) (Forall @"d" d) (Forall @"e" e) -> x a b c d e .== y a b c d e + -- * Running KnuckleDragger proofs + , KD, runKD, runKDWith, use --- | Chaining lemmas that depend on a single quantified variable. Overlapping version for 'SBool' that uses implication. -instance {-# OVERLAPPING #-} SymVal a => ChainLemma (SBV a -> [SBool]) (SBV a -> SBool) where - makeSteps steps = [\a -> steps a !! i | i <- [0 .. length (steps undefined) - 1]] - makeInter _ x y = quantifiedBool $ \(Forall @"a" a) -> x a .=> y a + -- * Starting a calculation proof + , (|-), (⊢) --- | Chaining lemmas that depend on two quantified variables. Overlapping version for 'SBool' that uses implication. -instance {-# OVERLAPPING #-} (SymVal a, SymVal b) => ChainLemma (SBV a -> SBV b -> [SBool]) (SBV a -> SBV b -> SBool) where - makeSteps steps = [\a b -> steps a b !! i | i <- [0 .. length (steps undefined undefined) - 1]] - makeInter _ x y = quantifiedBool $ \(Forall @"a" a) (Forall @"b" b) -> x a b .=> y a b + -- * Sequence of calculation steps + , (=:), (≡) --- | Chaining lemmas that depend on three quantified variables. Overlapping version for 'SBool' that uses implication. -instance {-# OVERLAPPING #-} (SymVal a, SymVal b, SymVal c) => ChainLemma (SBV a -> SBV b -> SBV c -> [SBool]) (SBV a -> SBV b -> SBV c -> SBool) where - makeSteps steps = [\a b c -> steps a b c !! i | i <- [0 .. length (steps undefined undefined undefined) - 1]] - makeInter _ x y = quantifiedBool $ \(Forall @"a" a) (Forall @"b" b) (Forall @"c" c) -> x a b c .=> y a b c + -- * Supplying hints for a calculation step + , (?), hprf, hyp --- | Chaining lemmas that depend on four quantified variables. Overlapping version for 'SBool' that uses implication. -instance {-# OVERLAPPING #-} (SymVal a, SymVal b, SymVal c, SymVal d) => ChainLemma (SBV a -> SBV b -> SBV c -> SBV d -> [SBool]) (SBV a -> SBV b -> SBV c -> SBV d -> SBool) where - makeSteps steps = [\a b c d -> steps a b c d !! i | i <- [0 .. length (steps undefined undefined undefined undefined) - 1]] - makeInter _ x y = quantifiedBool $ \(Forall @"a" a) (Forall @"b" b) (Forall @"c" c) (Forall @"d" d) -> x a b c d .=> y a b c d + -- * Finishing up a calculational proof + , qed + ) where --- | Chaining lemmas that depend on five quantified variables. Overlapping version for 'SBool' that uses implication. -instance {-# OVERLAPPING #-} (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e) => ChainLemma (SBV a -> SBV b -> SBV c -> SBV d -> SBV e -> [SBool]) (SBV a -> SBV b -> SBV c -> SBV d -> SBV e -> SBool) where - makeSteps steps = [\a b c d e -> steps a b c d e !! i | i <- [0 .. length (steps undefined undefined undefined undefined undefined) - 1]] - makeInter _ x y = quantifiedBool $ \(Forall @"a" a) (Forall @"b" b) (Forall @"c" c) (Forall @"d" d) (Forall @"e" e) -> x a b c d e .=> y a b c d e +import Data.SBV.Tools.KD.KnuckleDragger diff --git a/Data/SBV/Tools/NaturalInduction.hs b/Data/SBV/Tools/NaturalInduction.hs --- a/Data/SBV/Tools/NaturalInduction.hs +++ b/Data/SBV/Tools/NaturalInduction.hs @@ -36,10 +36,10 @@ -- Q.E.D. -- >>> inductNat $ \n -> (sumSquaresToN n, ite (n .== 12) 0 ((n*(n+1)*(2*n+1)) `sEDiv` 6)) -- Falsifiable. Counter-example: +-- k = 11 :: Integer -- P(0) = (0,0) :: (Integer, Integer) -- P(k) = (506,506) :: (Integer, Integer) -- P(k+1) = (650,0) :: (Integer, Integer) --- k = 11 :: Integer inductNat :: SymVal a => (SInteger -> (SBV a, SBV a)) -> IO ThmResult inductNat = inductNatWith defaultSMTCfg diff --git a/Data/SBV/Utils/Lib.hs b/Data/SBV/Utils/Lib.hs --- a/Data/SBV/Utils/Lib.hs +++ b/Data/SBV/Utils/Lib.hs @@ -19,17 +19,21 @@ , stringToQFS, qfsToString , isKString , checkObservableName + , needsBars, isEnclosedInBars + , noSurrounding, unQuote, unBar, nameSupply + , curry2, curry3, curry4, curry5, curry6, curry7, curry8, curry9, curry10, curry11, curry12 + , uncurry2, uncurry3, uncurry4, uncurry5, uncurry6, uncurry7, uncurry8, uncurry9, uncurry10, uncurry11, uncurry12 ) where -import Data.Char (isSpace, chr, ord, toLower, isDigit) -import Data.List (isPrefixOf) +import Data.Char (isSpace, chr, ord, isDigit, isAscii, isAlphaNum) +import Data.List (isPrefixOf, isSuffixOf) import Data.Dynamic (fromDynamic, toDyn, Typeable) import Data.Maybe (fromJust, isJust, isNothing) import Numeric (readHex, showHex) -import Data.SBV.SMT.SMTLibNames (smtLibReservedNames) +import Data.SBV.SMT.SMTLibNames (isReserved) -- | We have a nasty issue with the usual String/List confusion in Haskell. However, we can -- do a simple dynamic trick to determine where we are. The ice is thin here, but it seems to work. @@ -141,10 +145,114 @@ checkObservableName lbl | null lbl = Just "SBV.observe: Bad empty name!" - | map toLower lbl `elem` smtLibReservedNames + | isReserved lbl = Just $ "SBV.observe: The name chosen is reserved, please change it!: " ++ show lbl | "s" `isPrefixOf` lbl && all isDigit (drop 1 lbl) = Just $ "SBV.observe: Names of the form sXXX are internal to SBV, please use a different name: " ++ show lbl | True = Nothing +-- Remove one pair of surrounding 'c's, if present +noSurrounding :: Char -> String -> String +noSurrounding c (c':cs@(_:_)) | c == c' && c == last cs = init cs +noSurrounding _ s = s + +-- Remove a pair of surrounding quotes +unQuote :: String -> String +unQuote = noSurrounding '"' + +-- Remove a pair of surrounding bars +unBar :: String -> String +unBar = noSurrounding '|' + +-- Is this string surrounded by bars? NB. There shouldn't be any other bars or backslash anywhere +isEnclosedInBars :: String -> Bool +isEnclosedInBars nm = "|" `isPrefixOf` nm + && "|" `isSuffixOf` nm + && length nm > 2 + && not (any (`elem` ("|\\" :: String)) (drop 1 (init nm))) + +-- Does this name need bar in SMTLib2? +needsBars :: String -> Bool +needsBars "" = error "Impossible happened: needsBars received an empty name!" +needsBars nm@(h:tl) = not (isEnclosedInBars nm || (isAscii h && all validChar tl)) + where validChar x = isAscii x && (isAlphaNum x || x `elem` ("_" :: String)) + +-- An infinite supply of names, starting with a given set +nameSupply :: [String] -> [String] +nameSupply preSupply = preSupply ++ map mkUnique extras + where extras = ["x", "y", "z"] -- x y z + ++ [[c] | c <- ['a' .. 'w']] -- a b c ... w + ++ ['x' : show i | i <- [(1::Int) ..]] -- x1 x2 x3 ... + + -- make sure extras are different than preSupply. Note that extras + -- themselves are unique, so we only have to check the preSupply + mkUnique x | x `elem` preSupply = mkUnique $ x ++ "'" + | True = x + +-- Different arities of curry/uncurry +curry2 :: ((a, b) -> z) -> a -> b -> z +curry2 fn a b = fn (a, b) + +curry3 :: ((a, b, c) -> z) -> a -> b -> c -> z +curry3 fn a b c = fn (a, b, c) + +curry4 :: ((a, b, c, d) -> z) -> a -> b -> c -> d -> z +curry4 fn a b c d = fn (a, b, c, d) + +curry5 :: ((a, b, c, d, e) -> z) -> a -> b -> c -> d -> e -> z +curry5 fn a b c d e = fn (a, b, c, d, e) + +curry6 :: ((a, b, c, d, e, f) -> z) -> a -> b -> c -> d -> e -> f -> z +curry6 fn a b c d e f = fn (a, b, c, d, e, f) + +curry7 :: ((a, b, c, d, e, f, g) -> z) -> a -> b -> c -> d -> e -> f -> g -> z +curry7 fn a b c d e f g = fn (a, b, c, d, e, f, g) + +curry8 :: ((a, b, c, d, e, f, g, h) -> z) -> a -> b -> c -> d -> e -> f -> g -> h -> z +curry8 fn a b c d e f g h = fn (a, b, c, d, e, f, g, h) + +curry9 :: ((a, b, c, d, e, f, g, h, i) -> z) -> a -> b -> c -> d -> e -> f -> g -> h -> i -> z +curry9 fn a b c d e f g h i = fn (a, b, c, d, e, f, g, h, i) + +curry10 :: ((a, b, c, d, e, f, g, h, i, j) -> z) -> a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> z +curry10 fn a b c d e f g h i j = fn (a, b, c, d, e, f, g, h, i, j) + +curry11 :: ((a, b, c, d, e, f, g, h, i, j, k) -> z) -> a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> z +curry11 fn a b c d e f g h i j k = fn (a, b, c, d, e, f, g, h, i, j, k) + +curry12 :: ((a, b, c, d, e, f, g, h, i, j, k, l) -> z) -> a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> z +curry12 fn a b c d e f g h i j k l = fn (a, b, c, d, e, f, g, h, i, j, k, l) + +uncurry2 :: (a -> b -> z) -> (a, b) -> z +uncurry2 fn (a, b) = fn a b + +uncurry3 :: (a -> b -> c -> z) -> (a, b, c) -> z +uncurry3 fn (a, b, c) = fn a b c + +uncurry4 :: (a -> b -> c -> d -> z) -> (a, b, c, d) -> z +uncurry4 fn (a, b, c, d) = fn a b c d + +uncurry5 :: (a -> b -> c -> d -> e -> z) -> (a, b, c, d, e) -> z +uncurry5 fn (a, b, c, d, e) = fn a b c d e + +uncurry6 :: (a -> b -> c -> d -> e -> f -> z) -> (a, b, c, d, e, f) -> z +uncurry6 fn (a, b, c, d, e, f) = fn a b c d e f + +uncurry7 :: (a -> b -> c -> d -> e -> f -> g -> z) -> (a, b, c, d, e, f, g) -> z +uncurry7 fn (a, b, c, d, e, f, g) = fn a b c d e f g + +uncurry8 :: (a -> b -> c -> d -> e -> f -> g -> h -> z) -> (a, b, c, d, e, f, g, h) -> z +uncurry8 fn (a, b, c, d, e, f, g, h) = fn a b c d e f g h + +uncurry9 :: (a -> b -> c -> d -> e -> f -> g -> h -> i -> z) -> (a, b, c, d, e, f, g, h, i) -> z +uncurry9 fn (a, b, c, d, e, f, g, h, i) = fn a b c d e f g h i + +uncurry10 :: (a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> z) -> (a, b, c, d, e, f, g, h, i, j) -> z +uncurry10 fn (a, b, c, d, e, f, g, h, i, j) = fn a b c d e f g h i j + +uncurry11 :: (a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> z) -> (a, b, c, d, e, f, g, h, i, j, k) -> z +uncurry11 fn (a, b, c, d, e, f, g, h, i, j, k) = fn a b c d e f g h i j k + +uncurry12 :: (a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> z) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> z +uncurry12 fn (a, b, c, d, e, f, g, h, i, j, k, l) = fn a b c d e f g h i j k l diff --git a/Data/SBV/Utils/Numeric.hs b/Data/SBV/Utils/Numeric.hs --- a/Data/SBV/Utils/Numeric.hs +++ b/Data/SBV/Utils/Numeric.hs @@ -55,9 +55,9 @@ -- except careful on NaN, Infinities, and -0. fp2fp :: (RealFloat a, RealFloat b) => a -> b fp2fp x - | isNaN x = 0 / 0 - | isInfinite x && x < 0 = -1 / 0 - | isInfinite x = 1 / 0 + | isNaN x = 0 / 0 + | isInfinite x && x < 0 = -(1 / 0) + | isInfinite x = 1 / 0 | isNegativeZero x = negate 0 | True = fromRational (toRational x) diff --git a/Data/SBV/Utils/SExpr.hs b/Data/SBV/Utils/SExpr.hs --- a/Data/SBV/Utils/SExpr.hs +++ b/Data/SBV/Utils/SExpr.hs @@ -13,7 +13,11 @@ {-# OPTIONS_GHC -Wall -Werror #-} -module Data.SBV.Utils.SExpr (SExpr(..), parenDeficit, parseSExpr, parseSExprFunction, makeHaskellFunction) where +module Data.SBV.Utils.SExpr ( SExpr(..), parenDeficit, parseSExpr + , parseSExprFunction, makeHaskellFunction + , unQuote, simplifyECon + , nameSupply + ) where import Data.Bits (setBit, testBit) import Data.Char (isDigit, ord, isSpace) @@ -30,6 +34,8 @@ import Data.SBV.Core.SizedFloats import Data.SBV.Core.Data (nan, infinity, RoundingMode(..)) +import Data.SBV.Utils.Lib (unBar, unQuote, nameSupply) + import Data.SBV.Utils.Numeric (fpIsEqualObjectH, wordToFloat, wordToDouble) -- | ADT S-Expression format, suitable for representing get-model output of SMT-Lib @@ -58,10 +64,13 @@ go (':':cs) sofar = case break (`elem` stopper) cs of (pre, rest) -> go rest ((':':pre) : sofar) - go ('|':r) sofar = case span (/= '|') r of - (pre, '|':rest) -> go rest (pre : sofar) - (pre, rest) -> go rest (pre : sofar) + go ('|':r) sofar = let wrap s = '|' : s ++ "|" + in case span (/= '|') r of + (pre, '|':rest) -> go rest (wrap pre : sofar) + (pre, rest) -> go rest (wrap pre : sofar) + go (';':r) sofar = go (drop 1 (dropWhile (/= '\n') r)) sofar + go ('"':r) sofar = go rest (finalStr : sofar) where grabString [] acc = (reverse acc, []) -- Strictly speaking, this is the unterminated string case; but let's ignore grabString ('"' :'"':cs) acc = grabString cs ('"' :acc) @@ -77,7 +86,7 @@ -- characters that can stop the current token -- it is *crucial* that this list contains every character -- we can match in one of the previous cases! - stopper = " \t\n():|\"" + stopper = " \t\n():|\";" -- | The balance of parens in this string. If 0, this means it's a legit line! parenDeficit :: String -> Int @@ -562,43 +571,35 @@ Right (EApp [EApp [ECon o, e]]) | o == nm -> do (args, bd) <- lambda e let params | isCurried = unwords args | True = '(' : intercalate ", " args ++ ")" - return $ nm ++ " " ++ params ++ " = " ++ bd + return $ unBar nm ++ " " ++ params ++ " = " ++ bd _ -> Nothing where -- infinite supply of names; starting with the ones we're given preSupply = fromMaybe [] mbArgs - extras = ["x", "y", "z"] - ++ [[c] | c <- ['a' .. 'z'], c < 'x'] - ++ ['x' : show i | i <- [(1::Int) ..]] - - mkUnique x | x `elem` preSupply = mkUnique $ x ++ "'" - | True = x - - supply = preSupply ++ map mkUnique extras - lambda :: SExpr -> Maybe ([String], String) lambda (EApp [ECon "lambda", EApp args, bd]) = do as <- mapM getArg args - let env = zip as supply + let env = zip as (nameSupply preSupply) pure (map snd env, hprint env bd) lambda _ = Nothing getArg (EApp [ECon argName, _]) = Just argName getArg _ = Nothing +-- | z3 prints uninterpreted values like this: T!val!4 or T_val_4. Turn that into T_4 +simplifyECon :: String -> String +simplifyECon "" = "" +simplifyECon ('!':'v':'a':'l':'!':rest) = '_' : simplifyECon rest +simplifyECon ('_':'v':'a':'l':'_':rest) = '_' : simplifyECon rest +simplifyECon (c:cs) = c : simplifyECon cs + -- Print as a Haskell expression, with minimal parens. -- This isn't fool-proof; but it does an OK job hprint :: [(String, String)] -> SExpr -> String hprint env = go (0 :: Int) - where sanitize = map clean - - -- z3 uses ! as part of names, replace with _ - clean '!' = '_' - clean c = c - - go p e = case e of + where go p e = case e of ECon n | Just a <- n `lookup` env -> a - | True -> sanitize n + | True -> simplifyECon n ENum (i, _) -> cnst i EReal a -> cnst a EFloat f -> cnst f @@ -607,7 +608,7 @@ -- Handle lets EApp [ECon "let", EApp binders, rhs] -> - let getBind (EApp [ECon nm, def]) = sanitize nm ++ " = " ++ go 0 def + let getBind (EApp [ECon nm, def]) = simplifyECon nm ++ " = " ++ go 0 def getBind bnd = go 0 bnd binds = '{' : intercalate "; " (map getBind binders) ++ "}" diff --git a/Data/SBV/Utils/TDiff.hs b/Data/SBV/Utils/TDiff.hs --- a/Data/SBV/Utils/TDiff.hs +++ b/Data/SBV/Utils/TDiff.hs @@ -13,11 +13,15 @@ module Data.SBV.Utils.TDiff ( Timing(..) + , timeIf + , timeIfRNF , showTDiff + , getTimeStampIf + , getElapsedTime ) where -import Data.Time (NominalDiffTime) +import Data.Time (getCurrentTime, diffUTCTime, NominalDiffTime, UTCTime) import Data.IORef (IORef) import Data.List (intercalate) @@ -27,6 +31,10 @@ import Numeric (showFFloat) +import Control.Monad.Trans (liftIO, MonadIO) +import Control.DeepSeq (NFData(rnf)) + + -- | Specify how to save timing information, if at all. data Timing = NoTiming | PrintTiming | SaveTiming (IORef NominalDiffTime) @@ -59,3 +67,28 @@ aboveSeconds = map (\(t, v) -> show v ++ [t]) $ dropWhile (\p -> snd p == 0) [('d', days), ('h', hours), ('m', minutes)] fields = aboveSeconds ++ [secondsPicos] + +-- | Run an action and measure how long it took. We reduce the result to weak-head-normal-form, +-- so beware of the cases if the result is lazily computed; in which case we'll stop soon as the +-- result is in WHNF, and not necessarily fully calculated. +timeIf :: MonadIO m => Bool -> m a -> m (Maybe NominalDiffTime, a) +timeIf measureTime act = do mbStart <- getTimeStampIf measureTime + r <- act + r `seq` do mbElapsed <- getElapsedTime mbStart + pure (mbElapsed, r) + +-- | Same as 'timeIf', except we fully evaluate the result, via its the NFData instance. +timeIfRNF :: (NFData a, MonadIO m) => Bool -> m a -> m (Maybe NominalDiffTime, a) +timeIfRNF measureTime act = timeIf measureTime (act >>= \r -> rnf r `seq` pure r) + +-- | Get a time-stamp if we're asked to do so +getTimeStampIf :: MonadIO m => Bool -> m (Maybe UTCTime) +getTimeStampIf measureTime + | not measureTime = pure Nothing + | True = liftIO $ Just <$> getCurrentTime + +-- | Get elapsed time from the given beginning time, if any. +getElapsedTime :: MonadIO m => Maybe UTCTime -> m (Maybe NominalDiffTime) +getElapsedTime Nothing = pure Nothing +getElapsedTime (Just start) = liftIO $ do e <- getCurrentTime + pure $ Just (diffUTCTime e start) diff --git a/Documentation/SBV/Examples/KnuckleDragger/AppendRev.hs b/Documentation/SBV/Examples/KnuckleDragger/AppendRev.hs deleted file mode 100644 --- a/Documentation/SBV/Examples/KnuckleDragger/AppendRev.hs +++ /dev/null @@ -1,101 +0,0 @@ ------------------------------------------------------------------------------ --- | --- Module : Documentation.SBV.Examples.KnuckleDragger.AppendRev --- Copyright : (c) Levent Erkok --- License : BSD3 --- Maintainer: erkokl@gmail.com --- Stability : experimental --- --- Example use of the KnuckleDragger, on list append and reverses. ------------------------------------------------------------------------------ - -{-# LANGUAGE DataKinds #-} -{-# LANGUAGE DeriveAnyClass #-} -{-# LANGUAGE DeriveDataTypeable #-} -{-# LANGUAGE ScopedTypeVariables #-} -{-# LANGUAGE StandaloneDeriving #-} -{-# LANGUAGE TemplateHaskell #-} -{-# LANGUAGE TypeAbstractions #-} -{-# LANGUAGE TypeApplications #-} - -{-# OPTIONS_GHC -Wall -Werror #-} - -module Documentation.SBV.Examples.KnuckleDragger.AppendRev where - -import Prelude hiding (reverse, (++)) - -import Data.SBV -import Data.SBV.Tools.KnuckleDragger - -import Data.SBV.List ((.:), (++), reverse) -import qualified Data.SBV.List as SL - --- | Use an uninterpreted type for the elements -data Elt -mkUninterpretedSort ''Elt - --- | @xs ++ [] == xs@ --- --- We have: --- --- >>> appendNull --- Lemma: appendNull Q.E.D. --- [Proven] appendNull -appendNull :: IO Proof -appendNull = runKD $ lemma "appendNull" - (\(Forall @"xs" (xs :: SList Elt)) -> xs ++ SL.nil .== xs) - [] - --- | @(x : xs) ++ ys == x : (xs ++ ys)@ --- --- We have: --- --- >>> consApp --- Lemma: consApp Q.E.D. --- [Proven] consApp -consApp :: IO Proof -consApp = runKD $ lemma "consApp" - (\(Forall @"x" (x :: SElt)) (Forall @"xs" xs) (Forall @"ys" ys) -> (x .: xs) ++ ys .== x .: (xs ++ ys)) - [] - --- | @(xs ++ ys) ++ zs == xs ++ (ys ++ zs)@ --- --- We have: --- --- >>> appendAssoc --- Lemma: appendAssoc Q.E.D. --- [Proven] appendAssoc -appendAssoc :: IO Proof -appendAssoc = runKD $ do - let p :: SymVal a => SList a -> SList a -> SList a -> SBool - p xs ys zs = xs ++ (ys ++ zs) .== (xs ++ ys) ++ zs - - lemma "appendAssoc" - (\(Forall @"xs" (xs :: SList Elt)) (Forall @"ys" ys) (Forall @"zs" zs) -> p xs ys zs) - [] - --- | @reverse (reverse xs) == xs@ --- --- We have: --- --- >>> reverseReverse --- Lemma: revApp Q.E.D. --- Lemma: reverseReverse Q.E.D. --- [Proven] reverseReverse -reverseReverse :: IO Proof -reverseReverse = runKD $ do - - -- Helper lemma: @reverse (xs ++ ys) .== reverse ys ++ reverse xs@ - let ra :: SymVal a => SList a -> SList a -> SBool - ra xs ys = reverse (xs ++ ys) .== reverse ys ++ reverse xs - - revApp <- lemma "revApp" (\(Forall @"xs" (xs :: SList Elt)) (Forall @"ys" ys) -> ra xs ys) - -- induction is always done on the last argument, so flip to make sure we induct on xs - [induct (flip (ra @Elt))] - - let p :: SymVal a => SList a -> SBool - p xs = reverse (reverse xs) .== xs - - lemma "reverseReverse" - (\(Forall @"xs" (xs :: SList Elt)) -> p xs) - [induct (p @Elt), revApp] diff --git a/Documentation/SBV/Examples/KnuckleDragger/CaseSplit.hs b/Documentation/SBV/Examples/KnuckleDragger/CaseSplit.hs --- a/Documentation/SBV/Examples/KnuckleDragger/CaseSplit.hs +++ b/Documentation/SBV/Examples/KnuckleDragger/CaseSplit.hs @@ -21,32 +21,41 @@ import Data.SBV import Data.SBV.Tools.KnuckleDragger --- | The default settings for z3 have trouble running this proof out-of-the-box. --- We have to pass auto_config=false to z3! -z3NoAutoConfig :: SMTConfig -z3NoAutoConfig = z3{extraArgs = ["auto_config=false"]} - -- | Prove that @2n^2 + n + 1@ is not divisible by @3@. -- -- We have: -- -- >>> notDiv3 --- Chain: case_n_mod_3_eq_0 --- Lemma: case_n_mod_3_eq_0.1 Q.E.D. --- Lemma: case_n_mod_3_eq_0.2 Q.E.D. --- Lemma: case_n_mod_3_eq_0 Q.E.D. --- Chain: case_n_mod_3_eq_1 --- Lemma: case_n_mod_3_eq_1.1 Q.E.D. --- Lemma: case_n_mod_3_eq_1.2 Q.E.D. --- Lemma: case_n_mod_3_eq_1 Q.E.D. --- Chain: case_n_mod_3_eq_2 --- Lemma: case_n_mod_3_eq_2.1 Q.E.D. --- Lemma: case_n_mod_3_eq_2.2 Q.E.D. --- Lemma: case_n_mod_3_eq_2 Q.E.D. +-- Lemma: case_n_mod_3_eq_0 +-- Asms : 1 Q.E.D. +-- Step : 1 Q.E.D. +-- Step : 2 Q.E.D. +-- Step : 3 Q.E.D. +-- Step : 4 Q.E.D. +-- Step : 5 Q.E.D. +-- Result: Q.E.D. +-- Lemma: case_n_mod_3_eq_1 +-- Asms : 1 Q.E.D. +-- Step : 1 Q.E.D. +-- Step : 2 Q.E.D. +-- Step : 3 Q.E.D. +-- Step : 4 Q.E.D. +-- Step : 5 Q.E.D. +-- Step : 6 Q.E.D. +-- Result: Q.E.D. +-- Lemma: case_n_mod_3_eq_2 +-- Asms : 1 Q.E.D. +-- Step : 1 Q.E.D. +-- Step : 2 Q.E.D. +-- Step : 3 Q.E.D. +-- Step : 4 Q.E.D. +-- Step : 5 Q.E.D. +-- Step : 6 Q.E.D. +-- Result: Q.E.D. -- Lemma: notDiv3 Q.E.D. -- [Proven] notDiv3 notDiv3 :: IO Proof -notDiv3 = runKDWith z3NoAutoConfig $ do +notDiv3 = runKD $ do let s n = 2 * n * n + n + 1 p n = s n `sEMod` 3 ./= 0 @@ -54,38 +63,48 @@ -- Do the proof in 3 phases; one each for the possible value of n `mod` 3 being 0, 1, and 2 -- Note that we use the euclidian definition of division/modulus. + let case0 n = n `sEMod` 3 .== 0 + case1 n = n `sEMod` 3 .== 1 + case2 n = n `sEMod` 3 .== 2 + -- Case 0: n = 0 (mod 3) - case0 <- chainLemma "case_n_mod_3_eq_0" - (\(Forall @"n" n) -> (n `sEMod` 3 .== 0) .=> p n) - (\n -> let k = n `sEDiv` 3 - in [ n `sEMod` 3 .== 0 - , n .== 3 * k - , s n .== s (3 * k) - ]) - [] + c0 <- calc "case_n_mod_3_eq_0" + (\(Forall @"n" n) -> n `sEMod` 3 .== 0 .=> p n) $ + \n -> [case0 n] |- s n ? case0 n + =: let w = some "witness" $ \k -> n .== 3*k -- Grab the witness for the case + in s (3*w) + =: s (3*w) + =: 2*(3*w)*(3*w) + 3*w + 1 + =: 18*w*w + 3*w + 1 + =: 3*(6*w*w + w) + 1 + =: qed -- Case 1: n = 1 (mod 3) - case1 <- chainLemma "case_n_mod_3_eq_1" - (\(Forall @"n" n) -> (n `sEMod` 3 .== 1) .=> p n) - (\n -> let k = n `sEDiv` 3 - in [ n `sEMod` 3 .== 1 - , n .== 3 * k + 1 - , s n .== s (3 * k + 1) - ]) - [] + c1 <- calc "case_n_mod_3_eq_1" + (\(Forall @"n" n) -> n `sEMod` 3 .== 1 .=> p n) $ + \n -> [case1 n] |- s n ? case1 n + =: let w = some "witness" $ \k -> n .== 3*k+1 -- Grab the witness for n being 1 modulo 3 + in s (3*w+1) + =: 2*(3*w+1)*(3*w+1) + (3*w+1) + 1 + =: 2*(9*w*w + 3*w + 3*w + 1) + (3*w + 1) + 1 + =: 18*w*w + 12*w + 2 + 3*w + 2 + =: 18*w*w + 15*w + 4 + =: 3*(6*w*w + 5*w + 1) + 1 + =: qed -- Case 2: n = 2 (mod 3) - case2 <- chainLemma "case_n_mod_3_eq_2" - (\(Forall @"n" n) -> (n `sEMod` 3 .== 2) .=> p n) - (\n -> let k = n `sEDiv` 3 - in [ n `sEMod` 3 .== 2 - , n .== 3 * k + 2 - , s n .== s (3 * k + 2) - ]) - [] + c2 <- calc "case_n_mod_3_eq_2" + (\(Forall @"n" n) -> n `sEMod` 3 .== 2 .=> p n) $ + \n -> [case2 n] |- s n ? case2 n + =: let w = some "witness" $ \k -> n .== 3*k+2 -- Grab the witness for n being 2 modulo 3 + in s (3*w+2) + =: 2*(3*w+2)*(3*w+2) + (3*w+2) + 1 + =: 2*(9*w*w + 6*w + 6*w + 4) + (3*w + 2) + 1 + =: 18*w*w + 24*w + 8 + 3*w + 3 + =: 18*w*w + 27*w + 11 + =: 3*(6*w*w + 9*w + 3) + 2 + =: qed -- Note that z3 is smart enough to figure out the above cases are complete, so -- no extra completeness helper is needed. - lemma "notDiv3" - (\(Forall @"n" n) -> p n) - [case0, case1, case2] + lemma "notDiv3" (\(Forall @"n" n) -> p n) [c0, c1, c2] diff --git a/Documentation/SBV/Examples/KnuckleDragger/Induction.hs b/Documentation/SBV/Examples/KnuckleDragger/Induction.hs deleted file mode 100644 --- a/Documentation/SBV/Examples/KnuckleDragger/Induction.hs +++ /dev/null @@ -1,106 +0,0 @@ ------------------------------------------------------------------------------ --- | --- Module : Documentation.SBV.Examples.KnuckleDragger.Induction --- Copyright : (c) Levent Erkok --- License : BSD3 --- Maintainer: erkokl@gmail.com --- Stability : experimental --- --- Example use of the KnuckleDragger, for some inductive proofs ------------------------------------------------------------------------------ - -{-# LANGUAGE DataKinds #-} -{-# LANGUAGE TypeAbstractions #-} - -{-# OPTIONS_GHC -Wall -Werror #-} - -module Documentation.SBV.Examples.KnuckleDragger.Induction where - -import Prelude hiding (sum, length) - -import Data.SBV -import Data.SBV.Tools.KnuckleDragger - --- | Prove that sum of constants @c@ from @0@ to @n@ is @n*c@. --- --- We have: --- --- >>> sumConstProof --- Lemma: sumConst_correct Q.E.D. --- [Proven] sumConst_correct -sumConstProof :: IO Proof -sumConstProof = runKD $ do - let sum :: SInteger -> SInteger -> SInteger - sum = smtFunction "sum" $ \c n -> ite (n .== 0) 0 (c + sum c (n-1)) - - spec :: SInteger -> SInteger -> SInteger - spec c n = c * n - - p :: SInteger -> SInteger -> SBool - p c n = observe "imp" (sum c n) .== observe "spec" (spec c n) - - lemma "sumConst_correct" (\(Forall @"c" c) (Forall @"n" n) -> n .>= 0 .=> p c n) [induct p] - --- | Prove that sum of numbers from @0@ to @n@ is @n*(n-1)/2@. --- --- We have: --- --- >>> sumProof --- Lemma: sum_correct Q.E.D. --- [Proven] sum_correct -sumProof :: IO Proof -sumProof = runKD $ do - let sum :: SInteger -> SInteger - sum = smtFunction "sum" $ \n -> ite (n .== 0) 0 (n + sum (n - 1)) - - spec :: SInteger -> SInteger - spec n = (n * (n+1)) `sDiv` 2 - - p :: SInteger -> SBool - p n = observe "imp" (sum n) .== observe "spec" (spec n) - - lemma "sum_correct" (\(Forall @"n" n) -> n .>= 0 .=> p n) [induct p] - --- | Prove that sum of square of numbers from @0@ to @n@ is @n*(n+1)*(2n+1)/6@. --- --- We have: --- --- >>> sumSquareProof --- Lemma: sumSquare_correct Q.E.D. --- [Proven] sumSquare_correct -sumSquareProof :: IO Proof -sumSquareProof = runKD $ do - let sumSquare :: SInteger -> SInteger - sumSquare = smtFunction "sumSquare" $ \n -> ite (n .== 0) 0 (n * n + sumSquare (n - 1)) - - spec :: SInteger -> SInteger - spec n = (n * (n+1) * (2*n+1)) `sDiv` 6 - - p :: SInteger -> SBool - p n = observe "imp" (sumSquare n) .== observe "spec" (spec n) - - lemma "sumSquare_correct" (\(Forall @"n" n) -> n .>= 0 .=> p n) [induct p] - --- | Prove that @11^n - 4^n@ is always divisible by 7. Note that power operator is hard for --- SMT solvers to deal with due to non-linearity. For this example, we use cvc5 to discharge --- the final goal, where z3 can't converge on it. --- --- We have: --- --- >>> elevenMinusFour --- Lemma: pow0 Q.E.D. --- Lemma: powN Q.E.D. --- Lemma: elevenMinusFour Q.E.D. --- [Proven] elevenMinusFour -elevenMinusFour :: IO Proof -elevenMinusFour = runKD $ do - let pow :: SInteger -> SInteger -> SInteger - pow = smtFunction "pow" $ \x y -> ite (y .== 0) 1 (x * pow x (y - 1)) - - emf :: SInteger -> SBool - emf n = 7 `sDivides` (11 `pow` n - 4 `pow` n) - - pow0 <- lemma "pow0" (\(Forall @"x" x) -> x `pow` 0 .== 1) [] - powN <- lemma "powN" (\(Forall @"x" x) (Forall @"n" n) -> n .>= 0 .=> x `pow` (n+1) .== x * x `pow` n) [] - - lemmaWith cvc5 "elevenMinusFour" (\(Forall @"n" n) -> n .>= 0 .=> emf n) [pow0, powN, induct emf] diff --git a/Documentation/SBV/Examples/KnuckleDragger/Kleene.hs b/Documentation/SBV/Examples/KnuckleDragger/Kleene.hs --- a/Documentation/SBV/Examples/KnuckleDragger/Kleene.hs +++ b/Documentation/SBV/Examples/KnuckleDragger/Kleene.hs @@ -19,7 +19,6 @@ {-# LANGUAGE StandaloneDeriving #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE TypeAbstractions #-} -{-# LANGUAGE TypeSynonymInstances #-} {-# OPTIONS_GHC -Wall -Werror -Wno-unused-matches #-} @@ -62,26 +61,26 @@ -- We have: -- -- >>> kleeneProofs --- Axiom: par_assoc Axiom. --- Axiom: par_comm Axiom. --- Axiom: par_idem Axiom. --- Axiom: par_zero Axiom. --- Axiom: seq_assoc Axiom. --- Axiom: seq_zero Axiom. --- Axiom: seq_one Axiom. --- Axiom: rdistrib Axiom. --- Axiom: ldistrib Axiom. --- Axiom: unfold Axiom. --- Axiom: least_fix Axiom. +-- Axiom: par_assoc +-- Axiom: par_comm +-- Axiom: par_idem +-- Axiom: par_zero +-- Axiom: seq_assoc +-- Axiom: seq_zero +-- Axiom: seq_one +-- Axiom: rdistrib +-- Axiom: ldistrib +-- Axiom: unfold +-- Axiom: least_fix -- Lemma: par_lzero Q.E.D. -- Lemma: par_monotone Q.E.D. -- Lemma: seq_monotone Q.E.D. --- Chain: star_star_1 --- Lemma: star_star_1.1 Q.E.D. --- Lemma: star_star_1.2 Q.E.D. --- Lemma: star_star_1.3 Q.E.D. --- Lemma: star_star_1.4 Q.E.D. --- Lemma: star_star_1 Q.E.D. +-- Lemma: star_star_1 +-- Step : 1 Q.E.D. +-- Step : 2 Q.E.D. +-- Step : 3 Q.E.D. +-- Step : 4 Q.E.D. +-- Result: Q.E.D. -- Lemma: subset_eq Q.E.D. -- Lemma: star_star_2_2 Q.E.D. -- Lemma: star_star_2_3 Q.E.D. @@ -116,19 +115,19 @@ ] -- Various proofs: - par_lzero <- lemma "par_lzero" (\(Forall @"x" (x :: SKleene)) -> 0 + x .== x) kleene + par_lzero <- lemma "par_lzero" (\(Forall @"x" (x :: SKleene)) -> 0 + x .== x) kleene par_monotone <- lemma "par_monotone" (\(Forall @"x" (x :: SKleene)) (Forall @"y" y) (Forall @"z" z) -> x <= y .=> ((x + z) <= (y + z))) kleene seq_monotone <- lemma "seq_monotone" (\(Forall @"x" (x :: SKleene)) (Forall @"y" y) (Forall @"z" z) -> x <= y .=> ((x * z) <= (y * z))) kleene -- This one requires a chain of reasoning: x* x* == x* - star_star_1 <- chainLemma "star_star_1" (\(Forall @"x" (x :: SKleene)) -> star x * star x .== star x) - (\x -> [ star x * star x - , (1 + x * star x) * (1 + x * star x) - , (1 + 1) + (x * star x + x * star x) - , 1 + x * star x - , star x - ]) - kleene + star_star_1 <- calc "star_star_1" + (\(Forall @"x" (x :: SKleene)) -> star x * star x .== star x) $ + \x -> [] |- star x * star x ? unfold + =: (1 + x * star x) * (1 + x * star x) ? kleene + =: (1 + 1) + (x * star x + x * star x) ? par_idem + =: 1 + x * star x ? unfold + =: star x + =: qed subset_eq <- lemma "subset_eq" (\(Forall @"x" x) (Forall @"y" y) -> (x .== y) .== (x <= y .&& y <= x)) kleene diff --git a/Documentation/SBV/Examples/KnuckleDragger/ListLen.hs b/Documentation/SBV/Examples/KnuckleDragger/ListLen.hs deleted file mode 100644 --- a/Documentation/SBV/Examples/KnuckleDragger/ListLen.hs +++ /dev/null @@ -1,119 +0,0 @@ ------------------------------------------------------------------------------ --- | --- Module : Documentation.SBV.Examples.KnuckleDragger.ListLen --- Copyright : (c) Levent Erkok --- License : BSD3 --- Maintainer: erkokl@gmail.com --- Stability : experimental --- --- Example use of the KnuckleDragger, about lenghts of lists ------------------------------------------------------------------------------ - -{-# LANGUAGE CPP #-} -{-# LANGUAGE DataKinds #-} -{-# LANGUAGE DeriveAnyClass #-} -{-# LANGUAGE DeriveDataTypeable #-} -{-# LANGUAGE ScopedTypeVariables #-} -{-# LANGUAGE StandaloneDeriving #-} -{-# LANGUAGE TemplateHaskell #-} -{-# LANGUAGE TypeAbstractions #-} -{-# LANGUAGE TypeApplications #-} - -{-# OPTIONS_GHC -Wall -Werror -Wno-unused-do-bind #-} - -module Documentation.SBV.Examples.KnuckleDragger.ListLen where - -import Prelude hiding (sum, length, reverse, (++)) - -import Data.SBV -import Data.SBV.Tools.KnuckleDragger - -import qualified Data.SBV.List as SL - -#ifndef HADDOCK --- $setup --- >>> -- For doctest purposes only: --- >>> :set -XScopedTypeVariables --- >>> import Control.Exception -#endif - --- | Use an uninterpreted type for the elements -data Elt -mkUninterpretedSort ''Elt - --- | Prove that the length of a list is one more than the length of its tail. --- --- We have: --- --- >>> listLengthProof --- Lemma: length_correct Q.E.D. --- [Proven] length_correct -listLengthProof :: IO Proof -listLengthProof = runKD $ do - let length :: SList Elt -> SInteger - length = smtFunction "length" $ \xs -> ite (SL.null xs) 0 (1 + length (SL.tail xs)) - - spec :: SList Elt -> SInteger - spec = SL.length - - p :: SList Elt -> SBool - p xs = observe "imp" (length xs) .== observe "spec" (spec xs) - - lemma "length_correct" (\(Forall @"xs" xs) -> p xs) [induct p] - --- | It is instructive to see what kind of counter-example we get if a lemma fails to prove. --- Below, we do a variant of the 'listLengthProof', but with a bad implementation over integers, --- and see the counter-example. Our implementation returns an incorrect answer if the given list is longer --- than 5 elements and have 42 in it. We have: --- --- >>> badProof `catch` (\(_ :: SomeException) -> pure ()) --- Lemma: bad --- *** Failed to prove bad. --- Falsifiable. Counter-example: --- xs = [8,25,26,27,28,42] :: [Integer] --- imp = 42 :: Integer --- spec = 6 :: Integer -badProof :: IO () -badProof = runKD $ do - let length :: SList Integer -> SInteger - length = smtFunction "length" $ \xs -> ite (SL.null xs) 0 (1 + length (SL.tail xs)) - - badLength :: SList Integer -> SInteger - badLength xs = ite (SL.length xs .> 5 .&& 42 `SL.elem` xs) 42 (length xs) - - spec :: SList Integer -> SInteger - spec = SL.length - - p :: SList Integer -> SBool - p xs = observe "imp" (badLength xs) .== observe "spec" (spec xs) - - lemma "bad" (\(Forall @"xs" xs) -> p xs) [induct p] - - pure () - --- | @length (xs ++ ys) == length xs + length ys@ --- --- We have: --- --- >>> lenAppend --- Lemma: lenAppend Q.E.D. --- [Proven] lenAppend -lenAppend :: IO Proof -lenAppend = runKD $ lemma "lenAppend" - (\(Forall @"xs" (xs :: SList Elt)) (Forall @"ys" ys) -> - SL.length (xs SL.++ ys) .== SL.length xs + SL.length ys) - [] - --- | @length xs == length ys -> length (xs ++ ys) == 2 * length xs@ --- --- We have: --- --- >>> lenAppend2 --- Lemma: lenAppend2 Q.E.D. --- [Proven] lenAppend2 -lenAppend2 :: IO Proof -lenAppend2 = runKD $ lemma "lenAppend2" - (\(Forall @"xs" (xs :: SList Elt)) (Forall @"ys" ys) -> - SL.length xs .== SL.length ys - .=> SL.length (xs SL.++ ys) .== 2 * SL.length xs) - [] diff --git a/Documentation/SBV/Examples/KnuckleDragger/Lists.hs b/Documentation/SBV/Examples/KnuckleDragger/Lists.hs new file mode 100644 --- /dev/null +++ b/Documentation/SBV/Examples/KnuckleDragger/Lists.hs @@ -0,0 +1,962 @@ +----------------------------------------------------------------------------- +-- | +-- Module : Documentation.SBV.Examples.KnuckleDragger.Lists +-- Copyright : (c) Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- A variety of KnuckleDragger proofs on list processing functions. Note that +-- these proofs only hold for finite lists. SMT-solvers do not model infinite +-- lists, and hence all claims are for finite (but arbitrary-length) lists. +----------------------------------------------------------------------------- + +{-# LANGUAGE CPP #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveAnyClass #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE StandaloneDeriving #-} +{-# LANGUAGE TemplateHaskell #-} +{-# LANGUAGE TypeAbstractions #-} +{-# LANGUAGE TypeApplications #-} + +{-# OPTIONS_GHC -Wall -Werror -Wno-unused-do-bind #-} + +module Documentation.SBV.Examples.KnuckleDragger.Lists where + +import Prelude (IO, ($), Integer, Num(..), pure, id, (.), flip) + +import Data.SBV +import Data.SBV.List +import Data.SBV.Tools.KnuckleDragger + +#ifndef HADDOCK +-- $setup +-- >>> -- For doctest purposes only: +-- >>> :set -XScopedTypeVariables +-- >>> import Data.SBV +-- >>> import Control.Exception +#endif + +-- | Data declaration for an uninterpreted type, usually indicating source. +data A +mkUninterpretedSort ''A + +-- | Data declaration for an uninterpreted type, usually indicating target. +data B +mkUninterpretedSort ''B + +-- | Data declaration for an uninterpreted type, usually indicating an intermediate value. +data C +mkUninterpretedSort ''C + +-- * Appending null + +-- | @xs ++ [] == xs@ +-- +-- We have: +-- +-- >>> appendNull +-- Lemma: appendNull Q.E.D. +-- [Proven] appendNull +appendNull :: IO Proof +appendNull = runKD $ lemma "appendNull" (\(Forall @"xs" (xs :: SList A)) -> xs ++ nil .== xs) [] + +-- * Moving cons over append + +-- | @(x : xs) ++ ys == x : (xs ++ ys)@ +-- +-- We have: +-- +-- >>> consApp +-- Lemma: consApp Q.E.D. +-- [Proven] consApp +consApp :: IO Proof +consApp = runKD $ lemma "consApp" (\(Forall @"x" (x :: SA)) (Forall @"xs" xs) (Forall @"ys" ys) -> (x .: xs) ++ ys .== x .: (xs ++ ys)) [] + +-- * Associativity of append + +-- | @(xs ++ ys) ++ zs == xs ++ (ys ++ zs)@ +-- +-- We have: +-- +-- >>> appendAssoc +-- Lemma: appendAssoc Q.E.D. +-- [Proven] appendAssoc +-- +-- Surprisingly, z3 can prove this without any induction. (Since SBV's append translates directly to +-- the concatenation of sequences in SMTLib, it must trigger an internal heuristic in z3 +-- that proves it right out-of-the-box!) +appendAssoc :: IO Proof +appendAssoc = runKD $ + lemma "appendAssoc" (\(Forall @"xs" (xs :: SList A)) (Forall @"ys" ys) (Forall @"zs" zs) -> xs ++ (ys ++ zs) .== (xs ++ ys) ++ zs) [] + +-- * Reverse and append + +-- | @reverse (x:xs) == reverse xs ++ [x]@ +-- +-- >>> revCons +-- Lemma: revCons Q.E.D. +-- [Proven] revCons +revCons :: IO Proof +revCons = runKD $ lemma "revCons" (\(Forall @"x" (x :: SA)) (Forall @"xs" xs) -> reverse (x .: xs) .== reverse xs ++ singleton x) [] + +-- | @reverse (xs ++ ys) .== reverse ys ++ reverse xs@ +-- +-- We have: +-- +-- >>> revApp +-- Inductive lemma: revApp +-- Base: revApp.Base Q.E.D. +-- Step: 1 Q.E.D. +-- Step: 2 Q.E.D. +-- Step: 3 Q.E.D. +-- Step: 4 Q.E.D. +-- Step: 5 Q.E.D. +-- Step: revApp.Step Q.E.D. +-- [Proven] revApp +revApp :: IO Proof +revApp = runKD $ + induct "revApp" + (\(Forall @"xs" (xs :: SList A)) (Forall @"ys" ys) -> reverse (xs ++ ys) .== reverse ys ++ reverse xs) $ + \ih (x :: SA) xs ys -> [] |- reverse ((x .: xs) ++ ys) + =: reverse (x .: (xs ++ ys)) + =: reverse (xs ++ ys) ++ singleton x ? ih + =: (reverse ys ++ reverse xs) ++ singleton x + =: reverse ys ++ (reverse xs ++ singleton x) + =: reverse ys ++ reverse (x .: xs) + =: qed + +-- * Reversing twice is identity + +-- | @reverse (reverse xs) == xs@ +-- +-- We have: +-- +-- >>> reverseReverse +-- Inductive lemma: revApp +-- Base: revApp.Base Q.E.D. +-- Step: 1 Q.E.D. +-- Step: 2 Q.E.D. +-- Step: 3 Q.E.D. +-- Step: 4 Q.E.D. +-- Step: 5 Q.E.D. +-- Step: revApp.Step Q.E.D. +-- Inductive lemma: reverseReverse +-- Base: reverseReverse.Base Q.E.D. +-- Step: 1 Q.E.D. +-- Step: 2 Q.E.D. +-- Step: 3 Q.E.D. +-- Step: 4 Q.E.D. +-- Step: reverseReverse.Step Q.E.D. +-- [Proven] reverseReverse +reverseReverse :: IO Proof +reverseReverse = runKD $ do + + ra <- use revApp + + induct "reverseReverse" + (\(Forall @"xs" (xs :: SList A)) -> reverse (reverse xs) .== xs) $ + \ih (x :: SA) xs -> [] |- reverse (reverse (x .: xs)) + =: reverse (reverse xs ++ singleton x) ? ra + =: reverse (singleton x) ++ reverse (reverse xs) ? ih + =: singleton x ++ xs + =: x .: xs + =: qed + +-- * Lengths of lists + +-- | @length (x : xs) = 1 + length xs@ +-- +-- We have: +-- +-- >>> lengthTail +-- Lemma: lengthTail Q.E.D. +-- [Proven] lengthTail +lengthTail :: IO Proof +lengthTail = runKD $ lemma "lengthTail" (\(Forall @"x" (x :: SA)) (Forall @"xs" xs) -> length (x .: xs) .== 1 + length xs) [] + +-- | It is instructive to see what kind of counter-example we get if a lemma fails to prove. +-- Below, we do a variant of the 'lengthTail, but with a bad implementation over integers, +-- and see the counter-example. Our implementation returns an incorrect answer if the given list is longer +-- than 5 elements and have 42 in it. We have: +-- +-- >>> badLengthProof `catch` (\(_ :: SomeException) -> pure ()) +-- Lemma: badLengthProof +-- *** Failed to prove badLengthProof. +-- Falsifiable. Counter-example: +-- xs = [15,11,13,16,27,42] :: [Integer] +-- imp = 42 :: Integer +-- spec = 6 :: Integer +badLengthProof :: IO () +badLengthProof = runKD $ do + let badLength :: SList Integer -> SInteger + badLength xs = ite (length xs .> 5 .&& 42 `elem` xs) 42 (length xs) + + lemma "badLengthProof" (\(Forall @"xs" xs) -> observe "imp" (badLength xs) .== observe "spec" (length xs)) [] + + pure () + +-- | @length (xs ++ ys) == length xs + length ys@ +-- +-- We have: +-- +-- >>> lenAppend +-- Lemma: lenAppend Q.E.D. +-- [Proven] lenAppend +lenAppend :: IO Proof +lenAppend = runKD $ lemma "lenAppend" (\(Forall @"xs" (xs :: SList A)) (Forall @"ys" ys) -> length (xs ++ ys) .== length xs + length ys) [] + +-- | @length xs == length ys -> length (xs ++ ys) == 2 * length xs@ +-- +-- We have: +-- +-- >>> lenAppend2 +-- Lemma: lenAppend2 Q.E.D. +-- [Proven] lenAppend2 +lenAppend2 :: IO Proof +lenAppend2 = runKD $ + lemma "lenAppend2" (\(Forall @"xs" (xs :: SList A)) (Forall @"ys" ys) -> length xs .== length ys .=> length (xs ++ ys) .== 2 * length xs) [] + +-- * Any, all, and filtering + +-- | @not (all id xs) == any not xs@ +-- +-- A list of booleans is not all true, if any of them is false. We have: +-- +-- >>> allAny +-- Inductive lemma: allAny +-- Base: allAny.Base Q.E.D. +-- Step: 1 Q.E.D. +-- Step: 2 Q.E.D. +-- Step: 3 Q.E.D. +-- Step: 4 Q.E.D. +-- Step: allAny.Step Q.E.D. +-- [Proven] allAny +allAny :: IO Proof +allAny = runKD $ + induct "allAny" + (\(Forall @"xs" xs) -> sNot (all id xs) .== any sNot xs) $ + \ih x xs -> [] |- sNot (all id (x .: xs)) + =: sNot (x .&& all id xs) + =: (sNot x .|| sNot (all id xs)) ? ih + =: sNot x .|| any sNot xs + =: any sNot (x .: xs) + =: qed + +-- | If an integer list doesn't have 2 as an element, then filtering for @> 2@ or @.>= 2@ +-- yields the same result. We have: +-- +-- >>> filterEx +-- Inductive lemma: filterEx +-- Base: filterEx.Base Q.E.D. +-- Step: 1 Q.E.D. +-- Asms: 2 Q.E.D. +-- Step: 2 Q.E.D. +-- Step: filterEx.Step Q.E.D. +-- [Proven] filterEx +filterEx :: IO Proof +filterEx = runKD $ + induct "filterEx" + (\(Forall @"xs" xs) -> (2 :: SInteger) `notElem` xs .=> (filter (.> 2) xs .== filter (.>= 2) xs)) $ + \ih x xs -> let h = (2 :: SInteger) `notElem` (x .: xs) + in [h] |- filter (.> 2) (x .: xs) + =: ite (x .> 2) (x .: filter (.> 2) xs) (filter (.> 2) xs) ? [hyp h, hprf ih] + =: ite (x .> 2) (x .: filter (.>= 2) xs) (filter (.>= 2) xs) + =: qed + +-- | The 'filterEx' example above, except we get a counter-example if @2@ can be in the list. Note that +-- we don't need the induction tactic here. +-- +-- >>> filterEx2 `catch` (\(_ :: SomeException) -> pure ()) +-- Lemma: filterEx2 +-- *** Failed to prove filterEx2. +-- Falsifiable. Counter-example: +-- xs = [2] :: [Integer] +filterEx2 :: IO () +filterEx2 = runKD $ do + lemma "filterEx2" (\(Forall @"xs" xs) -> filter (.> (2 :: SInteger)) xs .== filter (.>= 2) xs) [] + + pure () + +-- * Map, append, and reverse + +-- | @map f (xs ++ ys) == map f xs ++ map f ys@ +-- +-- >>> mapAppend (uninterpret "f") +-- Inductive lemma: mapAppend +-- Base: mapAppend.Base Q.E.D. +-- Step: 1 Q.E.D. +-- Step: 2 Q.E.D. +-- Step: 3 Q.E.D. +-- Step: 4 Q.E.D. +-- Step: 5 Q.E.D. +-- Step: mapAppend.Step Q.E.D. +-- [Proven] mapAppend +mapAppend :: (SA -> SB) -> IO Proof +mapAppend f = runKD $ do + induct "mapAppend" + (\(Forall @"xs" (xs :: SList A)) (Forall @"ys" ys) -> map f (xs ++ ys) .== map f xs ++ map f ys) $ + \ih x xs ys -> [] |- map f ((x .: xs) ++ ys) + =: map f (x .: (xs ++ ys)) + =: f x .: map f (xs ++ ys) ? ih + =: f x .: (map f xs ++ map f ys) + =: (f x .: map f xs) ++ map f ys + =: map f (x .: xs) ++ map f ys + =: qed + +-- | @map f . reverse == reverse . map f@ +-- +-- >>> mapReverse +-- Inductive lemma: mapAppend +-- Base: mapAppend.Base Q.E.D. +-- Step: 1 Q.E.D. +-- Step: 2 Q.E.D. +-- Step: 3 Q.E.D. +-- Step: 4 Q.E.D. +-- Step: 5 Q.E.D. +-- Step: mapAppend.Step Q.E.D. +-- Inductive lemma: mapReverse +-- Base: mapReverse.Base Q.E.D. +-- Step: 1 Q.E.D. +-- Step: 2 Q.E.D. +-- Step: 3 Q.E.D. +-- Step: 4 Q.E.D. +-- Step: 5 Q.E.D. +-- Step: 6 Q.E.D. +-- Step: mapReverse.Step Q.E.D. +-- [Proven] mapReverse +mapReverse :: IO Proof +mapReverse = runKD $ do + let -- For an arbitrary uninterpreted function 'f': + f :: SA -> SB + f = uninterpret "f" + + mApp <- use (mapAppend f) + + induct "mapReverse" + (\(Forall @"xs" xs) -> reverse (map f xs) .== map f (reverse xs)) $ + \ih x xs -> [] |- reverse (map f (x .: xs)) + =: reverse (f x .: map f xs) + =: reverse (map f xs) ++ singleton (f x) ? ih + =: map f (reverse xs) ++ singleton (f x) + =: map f (reverse xs) ++ map f (singleton x) ? mApp + =: map f (reverse xs ++ singleton x) + =: map f (reverse (x .: xs)) + =: qed + +-- * Reverse and length + +-- | @length xs == length (reverse xs)@ +-- +-- We have: +-- +-- >>> revLen +-- Inductive lemma: revLen +-- Base: revLen.Base Q.E.D. +-- Step: 1 Q.E.D. +-- Step: 2 Q.E.D. +-- Step: 3 Q.E.D. +-- Step: 4 Q.E.D. +-- Step: revLen.Step Q.E.D. +-- [Proven] revLen +revLen :: IO Proof +revLen = runKD $ + induct "revLen" + (\(Forall @"xs" (xs :: SList A)) -> length (reverse xs) .== length xs) $ + \ih (x :: SA) xs -> [] |- length (reverse (x .: xs)) + =: length (reverse xs ++ singleton x) + =: length (reverse xs) + length (singleton x) ? ih + =: length xs + 1 + =: length (x .: xs) + =: qed + +-- | An example where we attempt to prove a non-theorem. Notice the counter-example +-- generated for: +-- +-- @length xs = ite (length xs .== 3) 5 (length xs)@ +-- +-- We have: +-- +-- >>> badRevLen `catch` (\(_ :: SomeException) -> pure ()) +-- Lemma: badRevLen +-- *** Failed to prove badRevLen. +-- Falsifiable. Counter-example: +-- xs = [A_1,A_2,A_1] :: [A] +badRevLen :: IO () +badRevLen = runKD $ do + lemma "badRevLen" (\(Forall @"xs" (xs :: SList A)) -> length (reverse xs) .== ite (length xs .== 3) 5 (length xs)) [] + + pure () + +-- * Foldr-map fusion + +-- | @foldr f a . map g = foldr (f . g) a@ +-- +-- We have: +-- +-- >>> foldrMapFusion +-- Inductive lemma: foldrMapFusion +-- Base: foldrMapFusion.Base Q.E.D. +-- Step: 1 Q.E.D. +-- Step: 2 Q.E.D. +-- Step: 3 Q.E.D. +-- Step: 4 Q.E.D. +-- Step: foldrMapFusion.Step Q.E.D. +-- [Proven] foldrMapFusion +foldrMapFusion :: IO Proof +foldrMapFusion = runKD $ do + let a :: SA + a = uninterpret "a" + + g :: SC -> SB + g = uninterpret "g" + + f :: SB -> SA -> SA + f = uninterpret "f" + + induct "foldrMapFusion" + (\(Forall @"xs" xs) -> foldr f a (map g xs) .== foldr (f . g) a xs) $ + \ih x xs -> [] |- foldr f a (map g (x .: xs)) + =: foldr f a (g x .: map g xs) + =: g x `f` foldr f a (map g xs) ? ih + =: g x `f` foldr (f . g) a xs + =: foldr (f . g) a (x .: xs) + =: qed + +-- * Foldr-foldr fusion + +-- | +-- +-- @ +-- Given f a = b and f (g x y) = h x (f y), for all x and y +-- We have: f . foldr g a = foldr h b +-- @ +-- +-- >>> foldrFusion +-- Inductive lemma: foldrFusion +-- Base: foldrFusion.Base Q.E.D. +-- Step: 1 Q.E.D. +-- Asms: 2 Q.E.D. +-- Step: 2 Q.E.D. +-- Asms: 3 Q.E.D. +-- Step: 3 Q.E.D. +-- Step: 4 Q.E.D. +-- Step: foldrFusion.Step Q.E.D. +-- [Proven] foldrFusion +foldrFusion :: IO Proof +foldrFusion = runKD $ do + let a :: SA + a = uninterpret "a" + + b :: SB + b = uninterpret "b" + + f :: SA -> SB + f = uninterpret "f" + + g :: SC -> SA -> SA + g = uninterpret "g" + + h :: SC -> SB -> SB + h = uninterpret "h" + + -- Assumptions under which the equality holds + h1 = f a .== b + h2 = quantifiedBool $ \(Forall @"x" x) (Forall @"y" y) -> f (g x y) .== h x (f y) + + induct "foldrFusion" + (\(Forall @"xs" xs) -> h1 .&& h2 .=> f (foldr g a xs) .== foldr h b xs) $ + \ih x xs -> [h1, h2] |- f (foldr g a (x .: xs)) + =: f (g x (foldr g a xs)) ? h2 + =: h x (f (foldr g a xs)) ? [hyp h1, hyp h2, hprf ih] + =: h x (foldr h b xs) + =: foldr h b (x .: xs) + =: qed + +-- * Foldr over append + +-- | @foldr f a (xs ++ ys) == foldr f (foldr f a ys) xs@ +-- +-- We have: +-- +-- >>> foldrOverAppend +-- Inductive lemma: foldrOverAppend +-- Base: foldrOverAppend.Base Q.E.D. +-- Step: 1 Q.E.D. +-- Step: 2 Q.E.D. +-- Step: 3 Q.E.D. +-- Step: 4 Q.E.D. +-- Step: foldrOverAppend.Step Q.E.D. +-- [Proven] foldrOverAppend +foldrOverAppend :: IO Proof +foldrOverAppend = runKD $ do + let a :: SA + a = uninterpret "a" + + f :: SA -> SA -> SA + f = uninterpret "f" + + induct "foldrOverAppend" + (\(Forall @"xs" xs) (Forall @"ys" ys) -> foldr f a (xs ++ ys) .== foldr f (foldr f a ys) xs) $ + \ih x xs ys -> [] |- foldr f a ((x .: xs) ++ ys) + =: foldr f a (x .: (xs ++ ys)) + =: x `f` foldr f a (xs ++ ys) ? ih + =: x `f` foldr f (foldr f a ys) xs + =: foldr f (foldr f a ys) (x .: xs) + =: qed + +-- * Foldl over append + +-- | @foldl f a (xs ++ ys) == foldl f (foldl f a xs) ys@ +-- +-- We have: +-- +-- >>> foldlOverAppend (uninterpret "f") +-- Inductive lemma: foldlOverAppend +-- Base: foldlOverAppend.Base Q.E.D. +-- Step: 1 Q.E.D. +-- Step: 2 Q.E.D. +-- Step: 3 Q.E.D. +-- Step: foldlOverAppend.Step Q.E.D. +-- [Proven] foldlOverAppend +foldlOverAppend :: (SB -> SA -> SB) -> IO Proof +foldlOverAppend f = runKD $ + -- z3 is smart enough to instantiate the IH correctly below, and the at clause isn't necessary. But we're being + -- explicit here to emphasize that the IH is used at a different value of a. + induct "foldlOverAppend" + (\(Forall @"xs" xs) (Forall @"ys" ys) (Forall @"a" a) -> foldl f a (xs ++ ys) .== foldl f (foldl f a xs) ys) $ + \ih x xs ys a -> [] |- foldl f a ((x .: xs) ++ ys) + =: foldl f a (x .: (xs ++ ys)) + =: foldl f (a `f` x) (xs ++ ys) ? ih `at` (Inst @"ys" ys, Inst @"a" (a `f` x)) + =: foldl f (foldl f (a `f` x) xs) ys + =: qed + +-- * Foldr-foldl correspondence + +-- | @foldr f e xs == foldl (flip f) e (reverse xs)@ +-- +-- We have: +-- +-- >>> foldrFoldlDuality +-- Inductive lemma: foldlOverAppend +-- Base: foldlOverAppend.Base Q.E.D. +-- Step: 1 Q.E.D. +-- Step: 2 Q.E.D. +-- Step: 3 Q.E.D. +-- Step: foldlOverAppend.Step Q.E.D. +-- Inductive lemma: foldrFoldlDuality +-- Base: foldrFoldlDuality.Base Q.E.D. +-- Step: 1 Q.E.D. +-- Step: 2 Q.E.D. +-- Step: 3 Q.E.D. +-- Step: 4 Q.E.D. +-- Step: 5 Q.E.D. +-- Step: 6 Q.E.D. +-- Step: foldrFoldlDuality.Step Q.E.D. +-- [Proven] foldrFoldlDuality +foldrFoldlDuality :: IO Proof +foldrFoldlDuality = runKD $ do + let f :: SA -> SB -> SB + f = uninterpret "f" + + foa <- use (foldlOverAppend (flip f)) + + induct "foldrFoldlDuality" + (\(Forall @"xs" xs) (Forall @"e" e) -> foldr f e xs .== foldl (flip f) e (reverse xs)) $ + \ih x xs e -> + let ff = flip f + rxs = reverse xs + in [] |- foldr f e (x .: xs) =: x `f` foldr f e xs ? ih + =: x `f` foldl ff e rxs + =: foldl ff e rxs `ff` x + =: foldl ff (foldl ff e rxs) (singleton x) ? foa + =: foldl ff e (rxs ++ singleton x) + =: foldl ff e (reverse (x .: xs)) + =: qed + +-- * Foldr-foldl duality, generalized + +-- | Given: +-- +-- @ +-- x \@ (y \@ z) = (x \@ y) \@ z (associativity of @) +-- and e \@ x = x (left unit) +-- and x \@ e = x (right unit) +-- @ +-- +-- Prove: +-- +-- @ +-- foldr (\@) e xs = foldl (\@) e xs +-- @ +-- +-- We have: +-- +-- >>> foldrFoldlDualityGeneralized +-- Inductive lemma: helper +-- Base: helper.Base Q.E.D. +-- Step: 1 Q.E.D. +-- Asms: 2 Q.E.D. +-- Step: 2 Q.E.D. +-- Asms: 3 Q.E.D. +-- Step: 3 Q.E.D. +-- Step: 4 Q.E.D. +-- Step: helper.Step Q.E.D. +-- Inductive lemma: foldrFoldlDuality +-- Base: foldrFoldlDuality.Base Q.E.D. +-- Step: 1 Q.E.D. +-- Asms: 2 Q.E.D. +-- Step: 2 Q.E.D. +-- Asms: 3 Q.E.D. +-- Step: 3 Q.E.D. +-- Asms: 4 Q.E.D. +-- Step: 4 Q.E.D. +-- Asms: 5 Q.E.D. +-- Step: 5 Q.E.D. +-- Step: 6 Q.E.D. +-- Step: foldrFoldlDuality.Step Q.E.D. +-- [Proven] foldrFoldlDuality +foldrFoldlDualityGeneralized :: IO Proof +foldrFoldlDualityGeneralized = runKD $ do + let (@) :: SA -> SA -> SA + (@) = uninterpret "|@|" + + e :: SA + e = uninterpret "e" + + -- Assumptions under which the equality holds + let assoc = quantifiedBool $ \(Forall @"x" x) (Forall @"y" y) (Forall @"z" z) -> x @ (y @ z) .== (x @ y) @ z + lunit = quantifiedBool $ \(Forall @"x" x) -> e @ x .== x + runit = quantifiedBool $ \(Forall @"x" x) -> x @ e .== x + + -- Helper: foldl (@) (y @ z) xs = y @ foldl (@) z xs + -- Note the instantiation of the IH at a different value for z. It turns out + -- we don't have to actually specify this since z3 can figure it out by itself, but we're being explicit. + helper <- induct "helper" + (\(Forall @"xs" xs) (Forall @"y" y) (Forall @"z" z) -> assoc .=> foldl (@) (y @ z) xs .== y @ foldl (@) z xs) $ + \ih x xs y z -> [assoc] |- foldl (@) (y @ z) (x .: xs) + =: foldl (@) ((y @ z) @ x) xs ? assoc + =: foldl (@) (y @ (z @ x)) xs ? [hyp assoc, hprf (ih `at` (Inst @"y" y, Inst @"z" (z @ x)))] + =: y @ foldl (@) (z @ x) xs + =: y @ foldl (@) z (x .: xs) + =: qed + + induct "foldrFoldlDuality" + (\(Forall @"xs" xs) -> assoc .&& lunit .&& runit .=> foldr (@) e xs .== foldl (@) e xs) $ + \ih x xs -> [assoc, lunit, runit] |- foldr (@) e (x .: xs) + =: x @ foldr (@) e xs ? [hyp assoc, hyp lunit, hyp runit, hprf ih] + =: x @ foldl (@) e xs ? [hyp assoc, hprf helper] + =: foldl (@) (x @ e) xs ? runit + =: foldl (@) x xs ? lunit + =: foldl (@) (e @ x) xs + =: foldl (@) e (x .: xs) + =: qed + +-- * Another foldl-foldr correspondence + +-- | Given: +-- +-- @ +-- (x \<+> y) \<*> z = x \<+> (y \<*> z) +-- and x \<+> e = e \<*> x +-- @ +-- +-- Proves: +-- +-- @ +-- foldr (\<+>) e xs = foldl (\<*>) e xs +-- @ +-- +-- In Bird's Introduction to Functional Programming book (2nd edition) this is called the second duality theorem. We have: +-- +-- >>> foldrFoldl +-- Inductive lemma: foldl over <*>/<+> +-- Base: foldl over <*>/<+>.Base Q.E.D. +-- Step: 1 Q.E.D. +-- Asms: 2 Q.E.D. +-- Step: 2 Q.E.D. +-- Asms: 3 Q.E.D. +-- Step: 3 Q.E.D. +-- Step: 4 Q.E.D. +-- Step: foldl over <*>/<+>.Step Q.E.D. +-- Inductive lemma: foldrFoldl +-- Base: foldrFoldl.Base Q.E.D. +-- Step: 1 Q.E.D. +-- Asms: 2 Q.E.D. +-- Step: 2 Q.E.D. +-- Asms: 3 Q.E.D. +-- Step: 3 Q.E.D. +-- Asms: 4 Q.E.D. +-- Step: 4 Q.E.D. +-- Step: 5 Q.E.D. +-- Step: foldrFoldl.Step Q.E.D. +-- [Proven] foldrFoldl +foldrFoldl :: IO Proof +foldrFoldl = runKD $ do + + let -- Declare the operators as uninterpreted functions + (<+>) :: SA -> SB -> SB + (<+>) = uninterpret "<+>" + + (<*>) :: SB -> SA -> SB + (<*>) = uninterpret "<*>" + + -- The unit element + e :: SB + e = uninterpret "e" + + -- Assumptions about the operators + let -- (x <+> y) <*> z == x <+> (y <*> z) + assoc = quantifiedBool $ \(Forall @"x" x) (Forall @"y" y) (Forall @"z" z) -> (x <+> y) <*> z .== x <+> (y <*> z) + + -- x <+> e == e <*> x + unit = quantifiedBool $ \(Forall @"x" x) -> x <+> e .== e <*> x + + -- Helper: x <+> foldl (<*>) y xs == foldl (<*>) (x <+> y) xs + helper <- + induct "foldl over <*>/<+>" + (\(Forall @"xs" xs) (Forall @"x" x) (Forall @"y" y) -> assoc .=> x <+> foldl (<*>) y xs .== foldl (<*>) (x <+> y) xs) $ + -- Using z to avoid confusion with the variable x already present, following Bird. + -- z3 can figure out the proper instantiation of ih so the at call is unnecessary, but being explicit is helpful. + \ih z xs x y -> [assoc] |- x <+> foldl (<*>) y (z .: xs) + =: x <+> foldl (<*>) (y <*> z) xs ? [hyp assoc, hprf (ih `at` (Inst @"x" x, Inst @"y" (y <*> z)))] + =: foldl (<*>) (x <+> (y <*> z)) xs ? assoc + =: foldl (<*>) ((x <+> y) <*> z) xs + =: foldl (<*>) (x <+> y) (z .: xs) + =: qed + + -- Final proof: + induct "foldrFoldl" + (\(Forall @"xs" xs) -> assoc .&& unit .=> foldr (<+>) e xs .== foldl (<*>) e xs) $ + \ih x xs -> [assoc, unit] |- foldr (<+>) e (x .: xs) + =: x <+> foldr (<+>) e xs ? [hyp assoc, hyp unit, hprf ih] + =: x <+> foldl (<*>) e xs ? [hyp assoc, hprf helper] + =: foldl (<*>) (x <+> e) xs ? unit + =: foldl (<*>) (e <*> x) xs + =: foldl (<*>) e (x .: xs) + =: qed + +-- * Bookkeeping law + +-- | Provided @f@ is associative and @a@ is its both left and right-unit: +-- +-- @foldr f a . concat == foldr f a . map (foldr f a)@ +-- +-- We have: +-- +-- >>> bookKeeping +-- Inductive lemma: foldBase +-- Base: foldBase.Base Q.E.D. +-- Step: 1 Q.E.D. +-- Asms: 2 Q.E.D. +-- Step: 2 Q.E.D. +-- Asms: 3 Q.E.D. +-- Step: 3 Q.E.D. +-- Step: 4 Q.E.D. +-- Step: foldBase.Step Q.E.D. +-- Inductive lemma: foldrOverAppend +-- Base: foldrOverAppend.Base Q.E.D. +-- Step: 1 Q.E.D. +-- Step: 2 Q.E.D. +-- Step: 3 Q.E.D. +-- Step: 4 Q.E.D. +-- Step: foldrOverAppend.Step Q.E.D. +-- Inductive lemma: bookKeeping +-- Base: bookKeeping.Base Q.E.D. +-- Step: 1 Q.E.D. +-- Step: 2 Q.E.D. +-- Asms: 3 Q.E.D. +-- Step: 3 Q.E.D. +-- Asms: 4 Q.E.D. +-- Step: 4 Q.E.D. +-- Step: 5 Q.E.D. +-- Step: 6 Q.E.D. +-- Step: bookKeeping.Step Q.E.D. +-- [Proven] bookKeeping +-- +-- NB. As of early 2025, we cannot express the above theorem in SBV directly, since it involves nested lambdas. +-- (On the right hand side map has an argument that is represented as a foldr, which itself has a lambda.) As +-- SMTLib moves to a higher-order logic, we intend to make such expressions readily expressable. In the mean time, +-- we use an equivalent (albeit roundabout) version, where we define map-foldr combo as a recursive function ourselves. +-- +-- NB. This theorem does not hold if @f@ does not have a left-unit! Consider the input @[[], [x]]@. Left hand side reduces to +-- @x@, while the right hand side reduces to: @f a x@. And unless @f@ is commutative or @a@ is not also a left-unit, +-- then one can find a counter-example. (Aside: if both left and right units exist for a binary operator, then they +-- are necessarily the same element, since @l = f l r = r@. So, an equivalent statement could simply say @f@ has +-- both left and right units.) A concrete counter-example is: +-- +-- @ +-- data T = A | B | C +-- +-- f :: T -> T -> T +-- f C A = A +-- f C B = A +-- f x _ = x +-- @ +-- +-- You can verify @f@ is associative. Also note that @C@ is the right-unit for @f@, but it isn't the left-unit. +-- In fact, @f@ has no-left unit by the above argument. In this case, the bookkeeping law produces @B@ for +-- the left-hand-side, and @A@ for the right-hand-side for the input @[[], [B]]@. +bookKeeping :: IO Proof +bookKeeping = runKD $ do + let a :: SA + a = uninterpret "a" + + f :: SA -> SA -> SA + f = uninterpret "f" + + -- Fuse map (foldr f a) in the theorem into one call to avoid nested lambdas. See above note. + mapFoldr :: SA -> SList [A] -> SList A + mapFoldr = smtFunction "mapFoldr" $ \e xss -> ite (null xss) + nil + (foldr f e (head xss) .: mapFoldr e (tail xss)) + + -- Assumptions about f + let assoc = quantifiedBool $ \(Forall @"x" x) (Forall @"y" y) (Forall @"z" z) -> x `f` (y `f` z) .== (x `f` y) `f` z + rUnit = quantifiedBool $ \(Forall @"x" x) -> x `f` a .== x + lUnit = quantifiedBool $ \(Forall @"x" x) -> a `f` x .== x + + -- Helper: + -- foldr f y xs = foldr f a xs `f` y + helper <- induct "foldBase" + (\(Forall @"xs" xs) (Forall @"y" y) -> lUnit .&& assoc .=> foldr f y xs .== foldr f a xs `f` y) $ + \ih x xs y -> [lUnit, assoc] |- foldr f y (x .: xs) + =: x `f` foldr f y xs ? [hyp lUnit, hyp assoc, hprf ih] + =: x `f` (foldr f a xs `f` y) ? assoc + =: (x `f` foldr f a xs) `f` y + =: foldr f a (x .: xs) `f` y + =: qed + + foa <- use foldrOverAppend + + induct "bookKeeping" + (\(Forall @"xss" xss) -> assoc .&& rUnit .&& lUnit .=> foldr f a (concat xss) .== foldr f a (mapFoldr a xss)) $ + \ih xs xss -> [assoc, rUnit, lUnit] |- foldr f a (concat (xs .: xss)) + =: foldr f a (xs ++ concat xss) ? foa + =: foldr f (foldr f a (concat xss)) xs ? [hyp assoc, hyp rUnit, hyp lUnit, hprf ih] + =: foldr f (foldr f a (mapFoldr a xss)) xs ? [hyp lUnit, hyp assoc, hprf (helper `at` (Inst @"xs" xs, Inst @"y" (foldr f a (mapFoldr a xss))))] + =: foldr f a xs `f` foldr f a (mapFoldr a xss) + =: foldr f a (foldr f a xs .: mapFoldr a xss) + =: foldr f a (mapFoldr a (xs .: xss)) + =: qed + +-- * Filter-append + +-- | @filter p (xs ++ ys) == filter p xs ++ filter p ys@ +-- +-- We have: +-- +-- >>> filterAppend (uninterpret "p") +-- Inductive lemma: filterAppend +-- Base: filterAppend.Base Q.E.D. +-- Step: 1 Q.E.D. +-- Step: 2 Q.E.D. +-- Step: 3 Q.E.D. +-- Step: 4 Q.E.D. +-- Step: 5 Q.E.D. +-- Step: filterAppend.Step Q.E.D. +-- [Proven] filterAppend +filterAppend :: (SA -> SBool) -> IO Proof +filterAppend p = runKD $ + induct "filterAppend" + (\(Forall @"xs" xs) (Forall @"ys" ys) -> filter p xs ++ filter p ys .== filter p (xs ++ ys)) $ + \ih x xs ys -> [] |- filter p (x .: xs) ++ filter p ys + =: ite (p x) (x .: filter p xs) (filter p xs) ++ filter p ys + =: ite (p x) (x .: filter p xs ++ filter p ys) (filter p xs ++ filter p ys) ? ih + =: ite (p x) (x .: filter p (xs ++ ys)) (filter p (xs ++ ys)) + =: filter p (x .: (xs ++ ys)) + =: filter p ((x .: xs) ++ ys) + =: qed + +-- | @filter p (concat xss) == concatMap (filter p xss)@ +-- +-- Similar to the book-keeping law, we cannot express this in SBV directly, since it involves a nested lambda. +-- @concatMap (filter p)@ maps a higher-order function @filter p@, which itself has a nested lambda. So, we use +-- our own merged definition. Hopefully we'll relax this as SMTLib gains more higher order features. +-- +-- We have: +-- +-- >>> filterConcat +-- Inductive lemma: filterAppend +-- Base: filterAppend.Base Q.E.D. +-- Step: 1 Q.E.D. +-- Step: 2 Q.E.D. +-- Step: 3 Q.E.D. +-- Step: 4 Q.E.D. +-- Step: 5 Q.E.D. +-- Step: filterAppend.Step Q.E.D. +-- Inductive lemma: filterConcat +-- Base: filterConcat.Base Q.E.D. +-- Step: 1 Q.E.D. +-- Step: 2 Q.E.D. +-- Step: 3 Q.E.D. +-- Step: 4 Q.E.D. +-- Step: filterConcat.Step Q.E.D. +-- [Proven] filterConcat +filterConcat :: IO Proof +filterConcat = runKD $ do + let -- For an arbitrary uninterpreted prediate 'p': + p :: SA -> SBool + p = uninterpret "p" + + -- Fuse concatMap (filter p) in the theorem to avoid nested lambdas. See above note + concatMapFilter :: (SA -> SBool) -> SList [A] -> SList A + concatMapFilter pred = smtFunction "concatMapFilter" $ \xs -> ite (null xs) + nil + (filter pred (head xs) ++ concatMapFilter pred (tail xs)) + + + fa <- use $ filterAppend p + + induct "filterConcat" + (\(Forall @"xss" xss) -> filter p (concat xss) .== concatMapFilter p xss) $ + \ih xs xss -> [] |- filter p (concat (xs .: xss)) + =: filter p (xs ++ concat xss) ? fa + =: filter p xs ++ filter p (concat xss) ? ih + =: filter p xs ++ concatMapFilter p xss + =: concatMapFilter p (xs .: xss) + =: qed + +-- * Map and filter don't commute + +-- | In general, mapping and filtering operations do not commute. We'll see the kind of counter-example we get from SBV if +-- we attempt to prove: +-- +-- >>> mapFilter `catch` (\(_ :: SomeException) -> pure ()) +-- Lemma: badMapFilter +-- *** Failed to prove badMapFilter. +-- Falsifiable. Counter-example: +-- xs = [A_3] :: [A] +-- lhs = [A_0] :: [A] +-- rhs = [] :: [A] +-- +-- f :: A -> A +-- f _ = A_0 +-- +-- p :: A -> Bool +-- p A_3 = True +-- p _ = False +-- +-- As expected, the function @f@ maps everything to @A_0@, and the predicate @p@ only lets @A_3@ through. As shown in the +-- counter-example, for the input @[A_3]@, left-hand-side filters nothing and the result is the singleton @A_0@. But the +-- map on the right-hand side maps everything to @[A_0]@ and the filter gets rid of the elements, resulting in an empty list. +mapFilter :: IO () +mapFilter = runKD $ do + let f :: SA -> SA + f = uninterpret "f" + + p :: SA -> SBool + p = uninterpret "p" + + lemma "badMapFilter" + (\(Forall @"xs" xs) -> observe "lhs" (map f (filter p xs)) .== observe "rhs" (filter p (map f xs))) + [] + + pure () + +{- HLint ignore reverseReverse "Redundant reverse" -} +{- HLint ignore allAny "Use and" -} +{- HLint ignore foldrMapFusion "Fuse foldr/map" -} +{- HLint ignore filterConcat "Move filter" -} diff --git a/Documentation/SBV/Examples/KnuckleDragger/Numeric.hs b/Documentation/SBV/Examples/KnuckleDragger/Numeric.hs new file mode 100644 --- /dev/null +++ b/Documentation/SBV/Examples/KnuckleDragger/Numeric.hs @@ -0,0 +1,175 @@ +----------------------------------------------------------------------------- +-- | +-- Module : Documentation.SBV.Examples.KnuckleDragger.Numeric +-- Copyright : (c) Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Example use of inductive KnuckleDragger proofs, over integers. +----------------------------------------------------------------------------- + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE TypeAbstractions #-} +{-# LANGUAGE TypeApplications #-} + +{-# OPTIONS_GHC -Wall -Werror #-} + +module Documentation.SBV.Examples.KnuckleDragger.Numeric where + +import Prelude hiding (sum, length) + +import Data.SBV +import Data.SBV.Tools.KnuckleDragger + +-- | Prove that sum of constants @c@ from @0@ to @n@ is @n*c@. +-- +-- We have: +-- +-- >>> sumConstProof +-- Inductive lemma: sumConst_correct +-- Base: sumConst_correct.Base Q.E.D. +-- Asms: 1 Q.E.D. +-- Step: 1 Q.E.D. +-- Asms: 2 Q.E.D. +-- Step: 2 Q.E.D. +-- Step: 3 Q.E.D. +-- Step: 4 Q.E.D. +-- Step: 5 Q.E.D. +-- Step: sumConst_correct.Step Q.E.D. +-- [Proven] sumConst_correct +sumConstProof :: IO Proof +sumConstProof = runKD $ do + let c :: SInteger + c = uninterpret "c" + + sum :: SInteger -> SInteger + sum = smtFunction "sum" $ \n -> ite (n .== 0) 0 (c + sum (n - 1)) + + spec :: SInteger -> SInteger + spec n = c * n + + induct "sumConst_correct" + (\(Forall @"n" n) -> n .>= 0 .=> sum n .== spec n) $ + \ih k -> [k .>= 0] |- sum (k+1) ? k .>= 0 + =: c + sum k ? [hprf ih, hyp (k .>= 0)] + =: c + spec k + =: c + c*k + =: c*(k+1) + =: spec (k+1) + =: qed + +-- | Prove that sum of numbers from @0@ to @n@ is @n*(n-1)/2@. +-- +-- Note that z3 (as of mid Feb 2025) can't converge on this quickly, but CVC5 does just fine. We have: +-- +-- >>> sumProof +-- Inductive lemma: sum_correct +-- Base: sum_correct.Base Q.E.D. +-- Asms: 1 Q.E.D. +-- Step: 1 Q.E.D. +-- Asms: 2 Q.E.D. +-- Step: 2 Q.E.D. +-- Step: 3 Q.E.D. +-- Step: sum_correct.Step Q.E.D. +-- [Proven] sum_correct +sumProof :: IO Proof +sumProof = runKD $ do + let sum :: SInteger -> SInteger + sum = smtFunction "sum" $ \n -> ite (n .== 0) 0 (n + sum (n - 1)) + + spec :: SInteger -> SInteger + spec n = (n * (n+1)) `sDiv` 2 + + p :: SInteger -> SBool + p n = sum n .== spec n + + inductWith cvc5 "sum_correct" + (\(Forall @"n" n) -> n .>= 0 .=> p n) $ + \ih k -> [k .>= 0] |- sum (k+1) ? k .>= 0 + =: k+1 + sum k ? [hprf ih, hyp (k .>= 0)] + =: k+1 + spec k + =: spec (k+1) + =: qed + +-- | Prove that sum of square of numbers from @0@ to @n@ is @n*(n+1)*(2n+1)/6@. +-- +-- Note that z3 (as of mid Feb 2025) can't converge on this quickly, but CVC5 does just fine. We have: +-- +-- >>> sumSquareProof +-- Inductive lemma: sumSquare_correct +-- Base: sumSquare_correct.Base Q.E.D. +-- Asms: 1 Q.E.D. +-- Step: 1 Q.E.D. +-- Asms: 2 Q.E.D. +-- Step: 2 Q.E.D. +-- Step: 3 Q.E.D. +-- Step: sumSquare_correct.Step Q.E.D. +-- [Proven] sumSquare_correct +sumSquareProof :: IO Proof +sumSquareProof = runKD $ do + let sumSquare :: SInteger -> SInteger + sumSquare = smtFunction "sumSquare" $ \n -> ite (n .== 0) 0 (n * n + sumSquare (n - 1)) + + spec :: SInteger -> SInteger + spec n = (n * (n+1) * (2*n+1)) `sDiv` 6 + + p :: SInteger -> SBool + p n = sumSquare n .== spec n + + inductWith cvc5 "sumSquare_correct" + (\(Forall @"n" n) -> n .>= 0 .=> p n) $ + \ih k -> [k .>= 0] |- sumSquare (k+1) ? k .>= 0 + =: (k+1)*(k+1) + sumSquare k ? [hprf ih, hyp (k .>= 0)] + =: (k+1)*(k+1) + spec k + =: spec (k+1) + =: qed + +-- | Prove that @11^n - 4^n@ is always divisible by 7. +-- +-- NB. As of Feb 2025, z3 struggles with the inductive step in this proof, but cvc5 performs just fine. +-- +-- We have: +-- +-- >>> elevenMinusFour +-- Lemma: powN Q.E.D. +-- Inductive lemma: elevenMinusFour +-- Base: elevenMinusFour.Base Q.E.D. +-- Step: 1 Q.E.D. +-- Asms: 2 Q.E.D. +-- Step: 2 Q.E.D. +-- Asms: 3 Q.E.D. +-- Step: 3 Q.E.D. +-- Step: 4 Q.E.D. +-- Step: 5 Q.E.D. +-- Asms: 6 Q.E.D. +-- Step: 6 Q.E.D. +-- Step: 7 Q.E.D. +-- Step: 8 Q.E.D. +-- Step: elevenMinusFour.Step Q.E.D. +-- [Proven] elevenMinusFour +elevenMinusFour :: IO Proof +elevenMinusFour = runKD $ do + let pow :: SInteger -> SInteger -> SInteger + pow = smtFunction "pow" $ \x y -> ite (y .== 0) 1 (x * pow x (y - 1)) + + emf :: SInteger -> SBool + emf n = 7 `sDivides` (11 `pow` n - 4 `pow` n) + + -- helper + powN <- lemma "powN" (\(Forall @"x" x) (Forall @"n" n) -> n .>= 0 .=> x `pow` (n+1) .== x * x `pow` n) [] + + inductWith cvc5 "elevenMinusFour" + (\(Forall @"n" n) -> n .>= 0 .=> emf n) $ + \ih k -> [k .>= 0] + |- emf (k+1) + =: 7 `sDivides` (11 `pow` (k+1) - 4 `pow` (k+1)) ? [hyp (k .>= 0), hprf (powN `at` (Inst @"x" (11 :: SInteger), Inst @"n" k))] + =: 7 `sDivides` (11 * 11 `pow` k - 4 `pow` (k+1)) ? [hyp (k .>= 0), hprf (powN `at` (Inst @"x" ( 4 :: SInteger), Inst @"n" k))] + =: 7 `sDivides` (11 * 11 `pow` k - 4 * 4 `pow` k) + =: 7 `sDivides` (7 * 11 `pow` k + 4 * 11 `pow` k - 4 * 4 `pow` k) + =: 7 `sDivides` (7 * 11 `pow` k + 4 * (11 `pow` k - 4 `pow` k)) ? [hyp (k .>= 0), hprf ih] + =: let x = some "x" (\v -> 7*v .== 11 `pow` k - 4 `pow` k) -- Apply the IH and grab the witness for it + in 7 `sDivides` (7 * 11 `pow` k + 4 * 7 * x) + =: 7 `sDivides` (7 * (11 `pow` k + 4 * x)) + =: sTrue + =: qed diff --git a/Documentation/SBV/Examples/KnuckleDragger/RevLen.hs b/Documentation/SBV/Examples/KnuckleDragger/RevLen.hs deleted file mode 100644 --- a/Documentation/SBV/Examples/KnuckleDragger/RevLen.hs +++ /dev/null @@ -1,79 +0,0 @@ ------------------------------------------------------------------------------ --- | --- Module : Documentation.SBV.Examples.KnuckleDragger.RevLen --- Copyright : (c) Levent Erkok --- License : BSD3 --- Maintainer: erkokl@gmail.com --- Stability : experimental --- --- Proof that reversing a list does not change its length. ------------------------------------------------------------------------------ - -{-# LANGUAGE CPP #-} -{-# LANGUAGE DataKinds #-} -{-# LANGUAGE DeriveAnyClass #-} -{-# LANGUAGE DeriveDataTypeable #-} -{-# LANGUAGE StandaloneDeriving #-} -{-# LANGUAGE TemplateHaskell #-} -{-# LANGUAGE TypeAbstractions #-} - -{-# OPTIONS_GHC -Wall -Werror -Wno-unused-do-bind #-} - -module Documentation.SBV.Examples.KnuckleDragger.RevLen where - -import Prelude hiding (length, reverse) - -import Data.SBV -import Data.SBV.Tools.KnuckleDragger - -import Data.SBV.List (reverse, length) - -#ifndef HADDOCK --- $setup --- >>> -- For doctest purposes only: --- >>> :set -XScopedTypeVariables --- >>> import Control.Exception -#endif - --- | Use an uninterpreted type for the elements -data Elt -mkUninterpretedSort ''Elt - --- | @length xs == length (reverse xs)@ --- --- We have: --- --- >>> revLen --- Lemma: revLen Q.E.D. --- [Proven] revLen -revLen :: IO Proof -revLen = runKD $ do - let p :: SList Elt -> SBool - p xs = length (reverse xs) .== length xs - - lemma "revLen" - (\(Forall @"xs" xs) -> p xs) - [induct p] - --- | An example where we attempt to prove a non-theorem. Notice the counter-example --- generated for: --- --- @length xs = ite (length xs .== 3) 5 (length xs)@ --- --- We have: --- --- >>> badRevLen `catch` (\(_ :: SomeException) -> pure ()) --- Lemma: badRevLen --- *** Failed to prove badRevLen. --- Falsifiable. Counter-example: --- xs = [Elt_1,Elt_2,Elt_1] :: [Elt] -badRevLen :: IO () -badRevLen = runKD $ do - let p :: SList Elt -> SBool - p xs = length (reverse xs) .== ite (length xs .== 3) 5 (length xs) - - lemma "badRevLen" - (\(Forall @"xs" xs) -> p xs) - [induct p] - - pure () diff --git a/Documentation/SBV/Examples/KnuckleDragger/ShefferStroke.hs b/Documentation/SBV/Examples/KnuckleDragger/ShefferStroke.hs new file mode 100644 --- /dev/null +++ b/Documentation/SBV/Examples/KnuckleDragger/ShefferStroke.hs @@ -0,0 +1,667 @@ +----------------------------------------------------------------------------- +-- | +-- Module : Documentation.SBV.Examples.KnuckleDragger.ShefferStroke +-- Copyright : (c) Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Inspired by https://www.philipzucker.com/cody_sheffer/, proving +-- that the axioms of sheffer stroke (i.e., nand in traditional boolean +-- logic), imply it is a boolean algebra. +----------------------------------------------------------------------------- + +{-# LANGUAGE CPP #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveAnyClass #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE NamedFieldPuns #-} +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE StandaloneDeriving #-} +{-# LANGUAGE TemplateHaskell #-} +{-# LANGUAGE TypeAbstractions #-} + +{-# OPTIONS_GHC -Wall -Werror #-} + +module Documentation.SBV.Examples.KnuckleDragger.ShefferStroke where + +import Prelude hiding ((<)) +import Data.List (intercalate) + +import Data.SBV +import Data.SBV.Tools.KnuckleDragger + +-- * Generalized Boolean Algebras + +-- | Capture what it means to be a boolean algebra. We follow Lean's +-- definition, as much as we can: . +-- Since there's no way in Haskell to capture properties together with a class, we'll represent the properties +-- separately. +class BooleanAlgebra α where + ﬧ :: α -> α + (⨆) :: α -> α -> α + (⨅) :: α -> α -> α + (≤) :: α -> α -> SBool + (<) :: α -> α -> SBool + (\\) :: α -> α -> α + (⇨) :: α -> α -> α + ⲳ :: α + т :: α + + infix 4 ≤ + infixl 6 ⨆ + infixl 7 ⨅ + +-- | Proofs needed for a boolean-algebra. Again, we follow Lean's definition here. Since we cannot +-- put these in the class definition above, we will keep them in a simple data-structure. +data BooleanAlgebraProof = BooleanAlgebraProof { + le_refl {- ∀ (a : α), a ≤ a -} :: Proof + , le_trans {- ∀ (a b c : α), a ≤ b → b ≤ c → a ≤ c -} :: Proof + , lt_iff_le_not_le {- (∀ (a b : α), a < b ↔ a ≤ b ∧ ¬b ≤ a) -} :: Proof + , le_antisymm {- ∀ (a b : α), a ≤ b → b ≤ a → a = b -} :: Proof + , le_sup_left {- ∀ (a b : α), a ≤ a ⊔ b -} :: Proof + , le_sup_right {- ∀ (a b : α), b ≤ a ⊔ b -} :: Proof + , sup_le {- ∀ (a b c : α), a ≤ c → b ≤ c → a ⊔ b ≤ c -} :: Proof + , inf_le_left {- ∀ (a b : α), a ⊓ b ≤ a -} :: Proof + , inf_le_right {- ∀ (a b : α), a ⊓ b ≤ b -} :: Proof + , le_inf {- ∀ (a b c : α), a ≤ b → a ≤ c → a ≤ b ⊓ c -} :: Proof + , le_sup_inf {- ∀ (x y z : α), (x ⊔ y) ⊓ (x ⊔ z) ≤ x ⊔ y ⊓ z -} :: Proof + , inf_compl_le_bot {- ∀ (x : α), x ⊓ xᶜ ≤ ⊥ -} :: Proof + , top_le_sup_compl {- ∀ (x : α), ⊤ ≤ x ⊔ xᶜ -} :: Proof + , le_top {- ∀ (a : α), a ≤ ⊤ -} :: Proof + , bot_le {- ∀ (a : α), ⊥ ≤ a -} :: Proof + , sdiff_eq {- (∀ (x y : α), x \ y = x ⊓ yᶜ) -} :: Proof + , himp_eq {- (∀ (x y : α), x ⇨ y = y ⊔ xᶜ) -} :: Proof + } + +-- | A somewhat prettier printer for a BooleanAlgebra proof +instance Show BooleanAlgebraProof where + show p = intercalate "\n" [ "BooleanAlgebraProof {" + , " le_refl : " ++ show (le_refl p) + , " le_trans : " ++ show (le_trans p) + , " lt_iff_le_not_le: " ++ show (lt_iff_le_not_le p) + , " le_antisymm : " ++ show (le_antisymm p) + , " le_sup_left : " ++ show (le_sup_left p) + , " le_sup_right : " ++ show (le_sup_right p) + , " sup_le : " ++ show (sup_le p) + , " inf_le_left : " ++ show (inf_le_left p) + , " inf_le_right : " ++ show (inf_le_right p) + , " le_inf : " ++ show (le_inf p) + , " le_sup_inf : " ++ show (le_sup_inf p) + , " inf_compl_le_bot: " ++ show (inf_compl_le_bot p) + , " top_le_sup_compl: " ++ show (top_le_sup_compl p) + , " le_top : " ++ show (le_top p) + , " bot_le : " ++ show (bot_le p) + , " sdiff_eq : " ++ show (sdiff_eq p) + , " himp_eq : " ++ show (himp_eq p) + , "}" + ] + +-- * The sheffer stroke + +-- | The abstract type for the domain. +data Stroke +mkUninterpretedSort ''Stroke + +-- | The sheffer stroke operator. +(⏐) :: SStroke -> SStroke -> SStroke +(⏐) = uninterpret "⏐" +infixl 7 ⏐ + +-- | The boolean algebra of the sheffer stroke. +instance BooleanAlgebra SStroke where + ﬧ x = x ⏐ x + a ⨆ b = ﬧ(a ⏐ b) + a ⨅ b = ﬧ a ⏐ ﬧ b + a ≤ b = a .== b ⨅ a + a < b = a ≤ b .&& a ./= b + a \\ b = a ⨅ ﬧ b + a ⇨ b = b ⨆ ﬧ a + ⲳ = arb ⏐ ﬧ arb where arb = some "ⲳ" (const sTrue) + т = ﬧ ⲳ + +-- | Double-negation +ﬧﬧ :: BooleanAlgebra a => a -> a +ﬧﬧ = ﬧ . ﬧ + +-- A couple of CPP defines make the code shorter to read +#define A (Forall @"A" (a :: SStroke)) +#define AAp A (Forall @"A'" (a' :: SStroke)) +#define AB A (Forall @"B" (b :: SStroke)) +#define ABC AB (Forall @"C" (c :: SStroke)) +#define X (Forall @"X" (x :: SStroke)) +#define XY X (Forall @"Y" (y :: SStroke)) +#define XYZ XY (Forall @"Z" (z :: SStroke)) + +-- | First Sheffer axiom: @ﬧﬧa == a@ +sheffer1 :: KD Proof +sheffer1 = axiom "ﬧﬧa == a" $ \A -> ﬧﬧ a .== a + +-- | Second Sheffer axiom: @a ⏐ (b ⏐ ﬧb) == ﬧa@ +sheffer2 :: KD Proof +sheffer2 = axiom "a ⏐ (b ⏐ ﬧb) == ﬧa" $ \AB -> a ⏐ (b ⏐ ﬧ b) .== ﬧ a + +-- | Third Sheffer axiom: @ﬧ(a ⏐ (b ⏐ c)) == (ﬧb ⏐ a) ⏐ (ﬧc ⏐ a)@ +sheffer3 :: KD Proof +sheffer3 = axiom "ﬧ(a ⏐ (b ⏐ c)) == (ﬧb ⏐ a) ⏐ (ﬧc ⏐ a)" $ \ABC -> ﬧ(a ⏐ (b ⏐ c)) .== (ﬧ b ⏐ a) ⏐ (ﬧ c ⏐ a) + +-- * Sheffer's stroke defines a boolean algebra + +-- | Prove that Sheffer stroke axioms imply it is a boolean algebra. We have: +-- +-- >>> shefferBooleanAlgebra +-- Axiom: ﬧﬧa == a +-- Axiom: a ⏐ (b ⏐ ﬧb) == ﬧa +-- Axiom: ﬧ(a ⏐ (b ⏐ c)) == (ﬧb ⏐ a) ⏐ (ﬧc ⏐ a) +-- Lemma: a | b = b | a +-- Step : 1 Q.E.D. +-- Step : 2 Q.E.D. +-- Step : 3 Q.E.D. +-- Step : 4 Q.E.D. +-- Step : 5 Q.E.D. +-- Step : 6 Q.E.D. +-- Step : 7 Q.E.D. +-- Result: Q.E.D. +-- Lemma: a | a′ = b | b′ +-- Step : 1 Q.E.D. +-- Step : 2 Q.E.D. +-- Step : 3 Q.E.D. +-- Step : 4 Q.E.D. +-- Step : 5 Q.E.D. +-- Result: Q.E.D. +-- Lemma: a ⊔ b = b ⊔ a Q.E.D. +-- Lemma: a ⊓ b = b ⊓ a Q.E.D. +-- Lemma: a ⊔ ⲳ = a Q.E.D. +-- Lemma: a ⊓ т = a Q.E.D. +-- Lemma: a ⊔ (b ⊓ c) = (a ⊔ b) ⊓ (a ⊔ c) Q.E.D. +-- Lemma: a ⊓ (b ⊔ c) = (a ⊓ b) ⊔ (a ⊓ c) Q.E.D. +-- Lemma: a ⊔ aᶜ = т Q.E.D. +-- Lemma: a ⊓ aᶜ = ⲳ Q.E.D. +-- Lemma: a ⊔ т = т +-- Step : 1 Q.E.D. +-- Step : 2 Q.E.D. +-- Step : 3 Q.E.D. +-- Step : 4 Q.E.D. +-- Step : 5 Q.E.D. +-- Step : 6 Q.E.D. +-- Result: Q.E.D. +-- Lemma: a ⊓ ⲳ = ⲳ +-- Step : 1 Q.E.D. +-- Step : 2 Q.E.D. +-- Step : 3 Q.E.D. +-- Step : 4 Q.E.D. +-- Step : 5 Q.E.D. +-- Step : 6 Q.E.D. +-- Result: Q.E.D. +-- Lemma: a ⊔ (a ⊓ b) = a +-- Step : 1 Q.E.D. +-- Step : 2 Q.E.D. +-- Step : 3 Q.E.D. +-- Step : 4 Q.E.D. +-- Step : 5 Q.E.D. +-- Result: Q.E.D. +-- Lemma: a ⊓ (a ⊔ b) = a +-- Step : 1 Q.E.D. +-- Step : 2 Q.E.D. +-- Step : 3 Q.E.D. +-- Step : 4 Q.E.D. +-- Step : 5 Q.E.D. +-- Result: Q.E.D. +-- Lemma: a ⊓ a = a +-- Step : 1 Q.E.D. +-- Step : 2 Q.E.D. +-- Result: Q.E.D. +-- Lemma: a ⊔ a' = т → a ⊓ a' = ⲳ → a' = aᶜ +-- Step : 1 Q.E.D. +-- Step : 2 Q.E.D. +-- Step : 3 Q.E.D. +-- Step : 4 Q.E.D. +-- Step : 5 Q.E.D. +-- Asms : 6 Q.E.D. +-- Step : 6 Q.E.D. +-- Step : 7 Q.E.D. +-- Step : 8 Q.E.D. +-- Step : 9 Q.E.D. +-- Asms : 10 Q.E.D. +-- Step : 10 Q.E.D. +-- Step : 11 Q.E.D. +-- Result: Q.E.D. +-- Lemma: aᶜᶜ = a Q.E.D. +-- Lemma: aᶜ = bᶜ → a = b Q.E.D. +-- Lemma: a ⊔ bᶜ = т → a ⊓ bᶜ = ⲳ → a = b Q.E.D. +-- Lemma: a ⊔ (aᶜ ⊔ b) = т +-- Step : 1 Q.E.D. +-- Step : 2 Q.E.D. +-- Step : 3 Q.E.D. +-- Step : 4 Q.E.D. +-- Step : 5 Q.E.D. +-- Step : 6 Q.E.D. +-- Result: Q.E.D. +-- Lemma: a ⊓ (aᶜ ⊓ b) = ⲳ +-- Step : 1 Q.E.D. +-- Step : 2 Q.E.D. +-- Step : 3 Q.E.D. +-- Step : 4 Q.E.D. +-- Step : 5 Q.E.D. +-- Step : 6 Q.E.D. +-- Result: Q.E.D. +-- Lemma: (a ⊔ b)ᶜ = aᶜ ⊓ bᶜ Q.E.D. +-- Lemma: (a ⨅ b)ᶜ = aᶜ ⨆ bᶜ Q.E.D. +-- Lemma: (a ⊔ (b ⊔ c)) ⊔ aᶜ = т Q.E.D. +-- Lemma: b ⊓ (a ⊔ (b ⊔ c)) = b Q.E.D. +-- Lemma: b ⊔ (a ⊓ (b ⊓ c)) = b Q.E.D. +-- Lemma: (a ⊔ (b ⊔ c)) ⊔ bᶜ = т +-- Step : 1 Q.E.D. +-- Step : 2 Q.E.D. +-- Step : 3 Q.E.D. +-- Step : 4 Q.E.D. +-- Step : 5 Q.E.D. +-- Step : 6 Q.E.D. +-- Step : 7 Q.E.D. +-- Step : 8 Q.E.D. +-- Step : 9 Q.E.D. +-- Result: Q.E.D. +-- Lemma: (a ⊔ (b ⊔ c)) ⊔ cᶜ = т Q.E.D. +-- Lemma: (a ⊔ b ⊔ c)ᶜ ⊓ a = ⲳ +-- Step : 1 Q.E.D. +-- Step : 2 Q.E.D. +-- Step : 3 Q.E.D. +-- Step : 4 Q.E.D. +-- Step : 5 Q.E.D. +-- Step : 6 Q.E.D. +-- Step : 7 Q.E.D. +-- Step : 8 Q.E.D. +-- Step : 9 Q.E.D. +-- Result: Q.E.D. +-- Lemma: (a ⊔ b ⊔ c)ᶜ ⊓ b = ⲳ Q.E.D. +-- Lemma: (a ⊔ b ⊔ c)ᶜ ⊓ c = ⲳ Q.E.D. +-- Lemma: (a ⊔ (b ⊔ c)) ⊔ ((a ⊔ b) ⊔ c)ᶜ = т +-- Step : 1 Q.E.D. +-- Step : 2 Q.E.D. +-- Step : 3 Q.E.D. +-- Step : 4 Q.E.D. +-- Step : 5 Q.E.D. +-- Step : 6 Q.E.D. +-- Step : 7 Q.E.D. +-- Step : 8 Q.E.D. +-- Result: Q.E.D. +-- Lemma: (a ⊔ (b ⊔ c)) ⊓ ((a ⊔ b) ⊔ c)ᶜ = ⲳ +-- Step : 1 Q.E.D. +-- Step : 2 Q.E.D. +-- Step : 3 Q.E.D. +-- Step : 4 Q.E.D. +-- Step : 5 Q.E.D. +-- Step : 6 Q.E.D. +-- Step : 7 Q.E.D. +-- Step : 8 Q.E.D. +-- Step : 9 Q.E.D. +-- Step : 10 Q.E.D. +-- Step : 11 Q.E.D. +-- Step : 12 Q.E.D. +-- Result: Q.E.D. +-- Lemma: a ⊔ (b ⊔ c) = (a ⊔ b) ⊔ c Q.E.D. +-- Lemma: a ⊓ (b ⊓ c) = (a ⊓ b) ⊓ c +-- Step : 1 Q.E.D. +-- Step : 2 Q.E.D. +-- Step : 3 Q.E.D. +-- Result: Q.E.D. +-- Lemma: a ≤ b → b ≤ a → a = b +-- Asms : 1 Q.E.D. +-- Step : 1 Q.E.D. +-- Step : 2 Q.E.D. +-- Asms : 3 Q.E.D. +-- Step : 3 Q.E.D. +-- Result: Q.E.D. +-- Lemma: a ≤ a Q.E.D. +-- Lemma: a ≤ b → b ≤ c → a ≤ c +-- Asms : 1 Q.E.D. +-- Step : 1 Q.E.D. +-- Asms : 2 Q.E.D. +-- Step : 2 Q.E.D. +-- Step : 3 Q.E.D. +-- Asms : 4 Q.E.D. +-- Step : 4 Q.E.D. +-- Result: Q.E.D. +-- Lemma: a < b ↔ a ≤ b ∧ ¬b ≤ a Q.E.D. +-- Lemma: a ≤ a ⊔ b Q.E.D. +-- Lemma: b ≤ a ⊔ b Q.E.D. +-- Lemma: a ≤ c → b ≤ c → a ⊔ b ≤ c +-- Asms : 1 Q.E.D. +-- Step : 1 Q.E.D. +-- Step : 2 Q.E.D. +-- Result: Q.E.D. +-- Lemma: a ⊓ b ≤ a Q.E.D. +-- Lemma: a ⊓ b ≤ b Q.E.D. +-- Lemma: a ≤ b → a ≤ c → a ≤ b ⊓ c +-- Asms : 1 Q.E.D. +-- Step : 1 Q.E.D. +-- Asms : 2 Q.E.D. +-- Step : 2 Q.E.D. +-- Step : 3 Q.E.D. +-- Result: Q.E.D. +-- Lemma: (x ⊔ y) ⊓ (x ⊔ z) ≤ x ⊔ y ⊓ z Q.E.D. +-- Lemma: x ⊓ xᶜ ≤ ⊥ Q.E.D. +-- Lemma: ⊤ ≤ x ⊔ xᶜ Q.E.D. +-- Lemma: a ≤ ⊤ +-- Step : 1 Q.E.D. +-- Step : 2 Q.E.D. +-- Step : 3 Q.E.D. +-- Result: Q.E.D. +-- Lemma: ⊥ ≤ a +-- Step : 1 Q.E.D. +-- Step : 2 Q.E.D. +-- Result: Q.E.D. +-- Lemma: x \ y = x ⊓ yᶜ Q.E.D. +-- Lemma: x ⇨ y = y ⊔ xᶜ Q.E.D. +-- BooleanAlgebraProof { +-- le_refl : [Proven] a ≤ a +-- le_trans : [Proven] a ≤ b → b ≤ c → a ≤ c +-- lt_iff_le_not_le: [Proven] a < b ↔ a ≤ b ∧ ¬b ≤ a +-- le_antisymm : [Proven] a ≤ b → b ≤ a → a = b +-- le_sup_left : [Proven] a ≤ a ⊔ b +-- le_sup_right : [Proven] b ≤ a ⊔ b +-- sup_le : [Proven] a ≤ c → b ≤ c → a ⊔ b ≤ c +-- inf_le_left : [Proven] a ⊓ b ≤ a +-- inf_le_right : [Proven] a ⊓ b ≤ b +-- le_inf : [Proven] a ≤ b → a ≤ c → a ≤ b ⊓ c +-- le_sup_inf : [Proven] (x ⊔ y) ⊓ (x ⊔ z) ≤ x ⊔ y ⊓ z +-- inf_compl_le_bot: [Proven] x ⊓ xᶜ ≤ ⊥ +-- top_le_sup_compl: [Proven] ⊤ ≤ x ⊔ xᶜ +-- le_top : [Proven] a ≤ ⊤ +-- bot_le : [Proven] ⊥ ≤ a +-- sdiff_eq : [Proven] x \ y = x ⊓ yᶜ +-- himp_eq : [Proven] x ⇨ y = y ⊔ xᶜ +-- } +shefferBooleanAlgebra :: IO BooleanAlgebraProof +shefferBooleanAlgebra = runKDWith z3{kdOptions = (kdOptions z3) {ribbonLength = 60}} $ do + + -- Get the axioms + sh1 <- sheffer1 + sh2 <- sheffer2 + sh3 <- sheffer3 + + commut <- calc "a | b = b | a" (\AB -> a ⏐ b .== b ⏐ a) $ + \a b -> [] ⊢ a ⏐ b ? sh1 + ≡ ﬧﬧ(a ⏐ b) ? sh1 + ≡ ﬧﬧ(a ⏐ ﬧﬧ b) + ≡ ﬧﬧ(a ⏐ (ﬧ b ⏐ ﬧ b)) ? sh3 + ≡ ﬧ ((ﬧﬧ b ⏐ a) ⏐ (ﬧﬧ b ⏐ a)) + ≡ ﬧﬧ(ﬧﬧ b ⏐ a) ? sh1 + ≡ ﬧﬧ b ⏐ a ? sh1 + ≡ b ⏐ a + ≡ qed + + all_bot <- calc "a | a′ = b | b′" (\AB -> a ⏐ ﬧ a .== b ⏐ ﬧ b) $ + \a b -> [] ⊢ a ⏐ ﬧ a ? sh1 + ≡ ﬧﬧ(a ⏐ ﬧ a) ? sh2 + ≡ ﬧ((a ⏐ ﬧ a) ⏐ (b ⏐ ﬧ b)) ? commut + ≡ ﬧ((b ⏐ ﬧ b) ⏐ (a ⏐ ﬧ a)) ? sh2 + ≡ ﬧﬧ (b ⏐ ﬧ b) ? sh1 + ≡ b ⏐ ﬧ b + ≡ qed + + commut1 <- lemma "a ⊔ b = b ⊔ a" (\AB -> a ⨆ b .== b ⨆ a) [commut] + commut2 <- lemma "a ⊓ b = b ⊓ a" (\AB -> a ⨅ b .== b ⨅ a) [commut] + + ident1 <- lemma "a ⊔ ⲳ = a" (\A -> a ⨆ ⲳ .== a) [sh1, sh2] + ident2 <- lemma "a ⊓ т = a" (\A -> a ⨅ т .== a) [sh1, sh2] + + distrib1 <- lemma "a ⊔ (b ⊓ c) = (a ⊔ b) ⊓ (a ⊔ c)" (\ABC -> a ⨆ (b ⨅ c) .== (a ⨆ b) ⨅ (a ⨆ c)) [sh1, sh3, commut] + distrib2 <- lemma "a ⊓ (b ⊔ c) = (a ⊓ b) ⊔ (a ⊓ c)" (\ABC -> a ⨅ (b ⨆ c) .== (a ⨅ b) ⨆ (a ⨅ c)) [sh1, sh3, commut] + + compl1 <- lemma "a ⊔ aᶜ = т" (\A -> a ⨆ ﬧ a .== т) [sh1, sh2, sh3, all_bot] + compl2 <- lemma "a ⊓ aᶜ = ⲳ" (\A -> a ⨅ ﬧ a .== ⲳ) [sh1, commut, all_bot] + + bound1 <- calc "a ⊔ т = т" (\A -> a ⨆ т .== т) $ + \(a :: SStroke) -> [] ⊢ a ⨆ т ? ident2 + ≡ (a ⨆ т) ⨅ т ? commut2 + ≡ т ⨅ (a ⨆ т) ? compl1 + ≡ (a ⨆ ﬧ a) ⨅ (a ⨆ т) ? distrib1 + ≡ a ⨆ (ﬧ a ⨅ т) ? ident2 + ≡ a ⨆ ﬧ a ? compl1 + ≡ (т :: SStroke) + ≡ qed + + bound2 <- calc "a ⊓ ⲳ = ⲳ" (\A -> a ⨅ ⲳ .== ⲳ) $ + \(a :: SStroke) -> [] ⊢ a ⨅ ⲳ ? ident1 + ≡ (a ⨅ ⲳ) ⨆ ⲳ ? commut1 + ≡ ⲳ ⨆ (a ⨅ ⲳ) ? compl2 + ≡ (a ⨅ ﬧ a) ⨆ (a ⨅ ⲳ) ? distrib2 + ≡ a ⨅ (ﬧ a ⨆ ⲳ) ? ident1 + ≡ a ⨅ ﬧ a ? compl2 + ≡ (ⲳ :: SStroke) + ≡ qed + + absorb1 <- calc "a ⊔ (a ⊓ b) = a" (\AB -> a ⨆ (a ⨅ b) .== a) $ + \(a :: SStroke) b -> [] ⊢ a ⨆ (a ⨅ b) ? ident2 + ≡ (a ⨅ т) ⨆ (a ⨅ b) ? distrib2 + ≡ a ⨅ (т ⨆ b) ? commut1 + ≡ a ⨅ (b ⨆ т) ? bound1 + ≡ a ⨅ т ? ident2 + ≡ a + ≡ qed + + absorb2 <- calc "a ⊓ (a ⊔ b) = a" (\AB -> a ⨅ (a ⨆ b) .== a) $ + \(a :: SStroke) b -> [] ⊢ a ⨅ (a ⨆ b) ? ident1 + ≡ (a ⨆ ⲳ) ⨅ (a ⨆ b) ? distrib1 + ≡ a ⨆ (ⲳ ⨅ b) ? commut2 + ≡ a ⨆ (b ⨅ ⲳ) ? bound2 + ≡ a ⨆ ⲳ ? ident1 + ≡ a + ≡ qed + + idemp2 <- calc "a ⊓ a = a" (\A -> a ⨅ a .== a) $ + \(a :: SStroke) -> [] ⊢ a ⨅ a ? ident1 + ≡ a ⨅ (a ⨆ ⲳ) ? absorb2 + ≡ a + ≡ qed + + inv <- calc "a ⊔ a' = т → a ⊓ a' = ⲳ → a' = aᶜ" + (\AAp -> a ⨆ a' .== т .=> a ⨅ a' .== ⲳ .=> a' .== ﬧ a) $ + \(a :: SStroke) a' -> [a ⨆ a' .== т, a ⨅ a' .== ⲳ] ⊢ a' ? ident2 + ≡ a' ⨅ т ? compl1 + ≡ a' ⨅ (a ⨆ ﬧ a) ? distrib2 + ≡ (a' ⨅ a) ⨆ (a' ⨅ ﬧ a) ? commut2 + ≡ (a' ⨅ a) ⨆ (ﬧ a ⨅ a') ? commut2 + ≡ (a ⨅ a') ⨆ (ﬧ a ⨅ a') ? a ⨅ a' .== ⲳ + ≡ ⲳ ⨆ (ﬧ a ⨅ a') ? compl2 + ≡ (a ⨅ ﬧ a) ⨆ (ﬧ a ⨅ a') ? commut2 + ≡ (ﬧ a ⨅ a) ⨆ (ﬧ a ⨅ a') ? distrib2 + ≡ ﬧ a ⨅ (a ⨆ a') ? a ⨆ a' .== т + ≡ ﬧ a ⨅ т ? ident2 + ≡ ﬧ a + ≡ qed + + dne <- lemma "aᶜᶜ = a" (\A -> ﬧﬧ a .== a) [inv, compl1, compl2, commut1, commut2] + inv_elim <- lemma "aᶜ = bᶜ → a = b" (\AB -> ﬧ a .== ﬧ b .=> a .== b) [dne] + + cancel <- lemma "a ⊔ bᶜ = т → a ⊓ bᶜ = ⲳ → a = b" (\AB -> a ⨆ ﬧ b .== т .=> a ⨅ ﬧ b .== ⲳ .=> a .== b) [inv, inv_elim] + + a1 <- calc "a ⊔ (aᶜ ⊔ b) = т" (\AB -> a ⨆ (ﬧ a ⨆ b) .== т) $ + \(a :: SStroke) b -> [] ⊢ a ⨆ (ﬧ a ⨆ b) ? ident2 + ≡ (a ⨆ (ﬧ a ⨆ b)) ⨅ т ? commut2 + ≡ т ⨅ (a ⨆ (ﬧ a ⨆ b)) ? compl1 + ≡ (a ⨆ ﬧ a) ⨅ (a ⨆ (ﬧ a ⨆ b)) ? distrib1 + ≡ a ⨆ (ﬧ a ⨅ (ﬧ a ⨆ b)) ? absorb2 + ≡ a ⨆ ﬧ a ? compl1 + ≡ (т :: SStroke) + ≡ qed + + a2 <- calc "a ⊓ (aᶜ ⊓ b) = ⲳ" (\AB -> a ⨅ (ﬧ a ⨅ b) .== ⲳ) $ + \(a :: SStroke) b -> [] ⊢ a ⨅ (ﬧ a ⨅ b) ? ident1 + ≡ (a ⨅ (ﬧ a ⨅ b)) ⨆ ⲳ ? commut1 + ≡ ⲳ ⨆ (a ⨅ (ﬧ a ⨅ b)) ? compl2 + ≡ (a ⨅ ﬧ a) ⨆ (a ⨅ (ﬧ a ⨅ b)) ? distrib2 + ≡ a ⨅ (ﬧ a ⨆ (ﬧ a ⨅ b)) ? absorb1 + ≡ a ⨅ ﬧ a ? compl2 + ≡ (ⲳ :: SStroke) + ≡ qed + + dm1 <- lemma "(a ⊔ b)ᶜ = aᶜ ⊓ bᶜ" (\AB -> ﬧ(a ⨆ b) .== ﬧ a ⨅ ﬧ b) + [a1, a2, dne, commut1, commut2, ident1, ident2, distrib1, distrib2] + + dm2 <- lemma "(a ⨅ b)ᶜ = aᶜ ⨆ bᶜ" (\AB -> ﬧ(a ⨅ b) .== ﬧ a ⨆ ﬧ b) + [a1, a2, dne, commut1, commut2, ident1, ident2, distrib1, distrib2] + + + d1 <- lemma "(a ⊔ (b ⊔ c)) ⊔ aᶜ = т" (\ABC -> (a ⨆ (b ⨆ c)) ⨆ ﬧ a .== т) + [a1, a2, commut1, ident1, ident2, distrib1, compl1, compl2, dm1, dm2, idemp2] + + e1 <- lemma "b ⊓ (a ⊔ (b ⊔ c)) = b" (\ABC -> b ⨅ (a ⨆ (b ⨆ c)) .== b) [distrib2, absorb1, absorb2, commut1] + + e2 <- lemma "b ⊔ (a ⊓ (b ⊓ c)) = b" (\ABC -> b ⨆ (a ⨅ (b ⨅ c)) .== b) [distrib1, absorb1, absorb2, commut2] + + f1 <- calc "(a ⊔ (b ⊔ c)) ⊔ bᶜ = т" (\ABC -> (a ⨆ (b ⨆ c)) ⨆ ﬧ b .== т) $ + \(a :: SStroke) b c -> [] ⊢ (a ⨆ (b ⨆ c)) ⨆ ﬧ b ? commut1 + ≡ ﬧ b ⨆ (a ⨆ (b ⨆ c)) ? ident2 + ≡ (ﬧ b ⨆ (a ⨆ (b ⨆ c))) ⨅ т ? commut2 + ≡ т ⨅ (ﬧ b ⨆ (a ⨆ (b ⨆ c))) ? compl1 + ≡ (b ⨆ ﬧ b) ⨅ (ﬧ b ⨆ (a ⨆ (b ⨆ c))) ? commut1 + ≡ (ﬧ b ⨆ b) ⨅ (ﬧ b ⨆ (a ⨆ (b ⨆ c))) ? distrib1 + ≡ ﬧ b ⨆ (b ⨅ (a ⨆ (b ⨆ c))) ? e1 + ≡ ﬧ b ⨆ b ? commut1 + ≡ b ⨆ ﬧ b ? compl1 + ≡ (т :: SStroke) + ≡ qed + + g1 <- lemma "(a ⊔ (b ⊔ c)) ⊔ cᶜ = т" (\ABC -> (a ⨆ (b ⨆ c)) ⨆ ﬧ c .== т) [commut1, f1] + + h1 <- calc "(a ⊔ b ⊔ c)ᶜ ⊓ a = ⲳ" (\ABC -> ﬧ(a ⨆ b ⨆ c) ⨅ a .== ⲳ) $ + \(a :: SStroke) b c -> [] ⊢ ﬧ(a ⨆ b ⨆ c) ⨅ a ? commut2 + ≡ a ⨅ ﬧ (a ⨆ b ⨆ c) ? dm1 + ≡ a ⨅ (ﬧ a ⨅ ﬧ b ⨅ ﬧ c) ? ident1 + ≡ (a ⨅ (ﬧ a ⨅ ﬧ b ⨅ ﬧ c)) ⨆ ⲳ ? commut1 + ≡ ⲳ ⨆ (a ⨅ (ﬧ a ⨅ ﬧ b ⨅ ﬧ c)) ? compl2 + ≡ (a ⨅ ﬧ a) ⨆ (a ⨅ (ﬧ a ⨅ ﬧ b ⨅ ﬧ c)) ? distrib2 + ≡ a ⨅ (ﬧ a ⨆ (ﬧ a ⨅ ﬧ b ⨅ ﬧ c)) ? commut2 + ≡ a ⨅ (ﬧ a ⨆ (ﬧ c ⨅ (ﬧ a ⨅ ﬧ b))) ? e2 + ≡ a ⨅ ﬧ a ? compl2 + ≡ (ⲳ :: SStroke) + ≡ qed + + i1 <- lemma "(a ⊔ b ⊔ c)ᶜ ⊓ b = ⲳ" (\ABC -> ﬧ(a ⨆ b ⨆ c) ⨅ b .== ⲳ) [commut1, h1] + j1 <- lemma "(a ⊔ b ⊔ c)ᶜ ⊓ c = ⲳ" (\ABC -> ﬧ(a ⨆ b ⨆ c) ⨅ c .== ⲳ) [a2, dne, commut2] + + assoc1 <- do + c1 <- calc "(a ⊔ (b ⊔ c)) ⊔ ((a ⊔ b) ⊔ c)ᶜ = т" + (\ABC -> (a ⨆ (b ⨆ c)) ⨆ ﬧ((a ⨆ b) ⨆ c) .== т) $ + \(a :: SStroke) b c -> [] ⊢ (a ⨆ (b ⨆ c)) ⨆ ﬧ((a ⨆ b) ⨆ c) ? dm1 + ≡ (a ⨆ (b ⨆ c)) ⨆ (ﬧ a ⨅ ﬧ b ⨅ ﬧ c) ? distrib1 + ≡ ((a ⨆ (b ⨆ c)) ⨆ (ﬧ a ⨅ ﬧ b)) ⨅ ((a ⨆ (b ⨆ c)) ⨆ ﬧ c) ? g1 + ≡ ((a ⨆ (b ⨆ c)) ⨆ (ﬧ a ⨅ ﬧ b)) ⨅ т ? ident2 + ≡ (a ⨆ (b ⨆ c)) ⨆ (ﬧ a ⨅ ﬧ b) ? distrib1 + ≡ ((a ⨆ (b ⨆ c)) ⨆ ﬧ a) ⨅ ((a ⨆ (b ⨆ c)) ⨆ ﬧ b) ? d1 + ≡ т ⨅ ((a ⨆ (b ⨆ c)) ⨆ ﬧ b) ? f1 + ≡ т ⨅ (т :: SStroke) ? idemp2 + ≡ (т :: SStroke) + ≡ qed + + c2 <- calc "(a ⊔ (b ⊔ c)) ⊓ ((a ⊔ b) ⊔ c)ᶜ = ⲳ" + (\ABC -> (a ⨆ (b ⨆ c)) ⨅ ﬧ((a ⨆ b) ⨆ c) .== ⲳ) $ + \(a :: SStroke) b c -> [] ⊢ (a ⨆ (b ⨆ c)) ⨅ ﬧ((a ⨆ b) ⨆ c) ? commut2 + ≡ ﬧ((a ⨆ b) ⨆ c) ⨅ (a ⨆ (b ⨆ c)) ? distrib2 + ≡ (ﬧ((a ⨆ b) ⨆ c) ⨅ a) ⨆ (ﬧ((a ⨆ b) ⨆ c) ⨅ (b ⨆ c)) ? commut2 + ≡ (a ⨅ ﬧ((a ⨆ b) ⨆ c)) ⨆ ((b ⨆ c) ⨅ ﬧ((a ⨆ b) ⨆ c)) ? commut2 + ≡ (ﬧ((a ⨆ b) ⨆ c) ⨅ a) ⨆ ((b ⨆ c) ⨅ ﬧ((a ⨆ b) ⨆ c)) ? h1 + ≡ ⲳ ⨆ ((b ⨆ c) ⨅ ﬧ((a ⨆ b) ⨆ c)) ? commut1 + ≡ ((b ⨆ c) ⨅ ﬧ((a ⨆ b) ⨆ c)) ⨆ ⲳ ? ident1 + ≡ (b ⨆ c) ⨅ ﬧ((a ⨆ b) ⨆ c) ? commut2 + ≡ ﬧ((a ⨆ b) ⨆ c) ⨅ (b ⨆ c) ? distrib2 + ≡ (ﬧ((a ⨆ b) ⨆ c) ⨅ b) ⨆ (ﬧ((a ⨆ b) ⨆ c) ⨅ c) ? j1 + ≡ (ﬧ((a ⨆ b) ⨆ c) ⨅ b) ⨆ ⲳ ? i1 + ≡ ⲳ ⨆ (ⲳ :: SStroke) ? ident1 + ≡ (ⲳ :: SStroke) + ≡ qed + + lemma "a ⊔ (b ⊔ c) = (a ⊔ b) ⊔ c" (\ABC -> a ⨆ (b ⨆ c) .== (a ⨆ b) ⨆ c) [c1, c2, cancel] + + assoc2 <- calc "a ⊓ (b ⊓ c) = (a ⊓ b) ⊓ c" (\ABC -> a ⨅ (b ⨅ c) .== (a ⨅ b) ⨅ c) $ + \(a :: SStroke) b c -> [] ⊢ a ⨅ (b ⨅ c) ? dne + ≡ ﬧﬧ(a ⨅ (b ⨅ c)) ? assoc1 + ≡ ﬧﬧ((a ⨅ b) ⨅ c) ? dne + ≡ ((a ⨅ b) ⨅ c) + ≡ qed + + le_antisymm <- calc "a ≤ b → b ≤ a → a = b" (\AB -> a ≤ b .=> b ≤ a .=> a .== b) $ + \(a :: SStroke) b -> [a ≤ b, b ≤ a] ⊢ a ? a ≤ b + ≡ b ⨅ a ? commut2 + ≡ a ⨅ b ? b ≤ a + ≡ b + ≡ qed + + le_refl <- lemma "a ≤ a" (\A -> a ≤ a) [idemp2] + + le_trans <- calc "a ≤ b → b ≤ c → a ≤ c" (\ABC -> a ≤ b .=> b ≤ c .=> a ≤ c) $ + \(a :: SStroke) b c -> [a ≤ b, b ≤ c] ⊢ a ? a ≤ b + ≡ b ⨅ a ? b ≤ c + ≡ (c ⨅ b) ⨅ a ? assoc2 + ≡ c ⨅ (b ⨅ a) ? a ≤ b + ≡ (c ⨅ a) + ≡ qed + + lt_iff_le_not_le <- lemma "a < b ↔ a ≤ b ∧ ¬b ≤ a" (\AB -> (a < b) .<=> a ≤ b .&& sNot (b ≤ a)) [sh3] + + le_sup_left <- lemma "a ≤ a ⊔ b" (\AB -> a ≤ a ⨆ b) [commut1, commut2, absorb2] + le_sup_right <- lemma "b ≤ a ⊔ b" (\AB -> a ≤ a ⨆ b) [commut1, commut2, absorb2] + + sup_le <- calc "a ≤ c → b ≤ c → a ⊔ b ≤ c" + (\ABC -> a ≤ c .=> b ≤ c .=> a ⨆ b ≤ c) $ + \(a :: SStroke) b c -> [a ≤ c, b ≤ c] ⊢ a ⨆ b ? [a ≤ c, b ≤ c] + ≡ (c ⨅ a) ⨆ (c ⨅ b) ? distrib2 + ≡ c ⨅ (a ⨆ b) + ≡ qed + + inf_le_left <- lemma "a ⊓ b ≤ a" (\AB -> a ⨅ b ≤ a) [assoc2, idemp2] + inf_le_right <- lemma "a ⊓ b ≤ b" (\AB -> a ⨅ b ≤ b) [commut2, inf_le_left] + + le_inf <- calc "a ≤ b → a ≤ c → a ≤ b ⊓ c" + (\ABC -> a ≤ b .=> a ≤ c .=> a ≤ b ⨅ c) $ + \(a :: SStroke) b c -> [a ≤ b, a ≤ c] ⊢ a ? a ≤ b + ≡ b ⨅ a ? a ≤ c + ≡ b ⨅ (c ⨅ a) ? assoc2 + ≡ (b ⨅ c ⨅ a) + ≡ qed + + le_sup_inf <- lemma "(x ⊔ y) ⊓ (x ⊔ z) ≤ x ⊔ y ⊓ z" + (\XYZ -> (x ⨆ y) ⨅ (x ⨆ z) ≤ x ⨆ y ⨅ z) + [distrib1, le_refl] + + inf_compl_le_bot <- lemma "x ⊓ xᶜ ≤ ⊥" (\X -> x ⨅ ﬧ x ≤ ⲳ) [compl2, le_refl] + top_le_sup_compl <- lemma "⊤ ≤ x ⊔ xᶜ" (\X -> т ≤ x ⨆ ﬧ x) [compl1, le_refl] + + le_top <- calc "a ≤ ⊤" (\A -> a ≤ т) $ + \(a :: SStroke)-> [] ⊢ a ≤ т + ≡ a .== т ⨅ a ? commut2 + ≡ a .== a ⨅ т ? ident2 + ≡ a .== a + ≡ qed + + bot_le <- calc "⊥ ≤ a" (\A -> ⲳ ≤ a) $ + \(a :: SStroke) -> [] ⊢ ⲳ ≤ a + ≡ ⲳ .== a ⨅ ⲳ ? bound2 + ≡ (ⲳ .== (ⲳ :: SStroke)) + ≡ qed + + sdiff_eq <- lemma "x \\ y = x ⊓ yᶜ" (\XY -> x \\ y .== x ⨅ ﬧ y) [] + himp_eq <- lemma "x ⇨ y = y ⊔ xᶜ" (\XY -> x ⇨ y .== y ⨆ ﬧ x) [] + + pure BooleanAlgebraProof { + le_refl {- ∀ (a : α), a ≤ a -} = le_refl + , le_trans {- ∀ (a b c : α), a ≤ b → b ≤ c → a ≤ c -} = le_trans + , lt_iff_le_not_le {- (∀ (a b : α), a < b ↔ a ≤ b ∧ ¬b ≤ a) -} = lt_iff_le_not_le + , le_antisymm {- ∀ (a b : α), a ≤ b → b ≤ a → a = b -} = le_antisymm + , le_sup_left {- ∀ (a b : α), a ≤ a ⊔ b -} = le_sup_left + , le_sup_right {- ∀ (a b : α), b ≤ a ⊔ b -} = le_sup_right + , sup_le {- ∀ (a b c : α), a ≤ c → b ≤ c → a ⊔ b ≤ c -} = sup_le + , inf_le_left {- ∀ (a b : α), a ⊓ b ≤ a -} = inf_le_left + , inf_le_right {- ∀ (a b : α), a ⊓ b ≤ b -} = inf_le_right + , le_inf {- ∀ (a b c : α), a ≤ b → a ≤ c → a ≤ b ⊓ c -} = le_inf + , le_sup_inf {- ∀ (x y z : α), (x ⊔ y) ⊓ (x ⊔ z) ≤ x ⊔ y ⊓ z -} = le_sup_inf + , inf_compl_le_bot {- ∀ (x : α), x ⊓ xᶜ ≤ ⊥ -} = inf_compl_le_bot + , top_le_sup_compl {- ∀ (x : α), ⊤ ≤ x ⊔ xᶜ -} = top_le_sup_compl + , le_top {- ∀ (a : α), a ≤ ⊤ -} = le_top + , bot_le {- ∀ (a : α), ⊥ ≤ a -} = bot_le + , sdiff_eq {- (∀ (x y : α), x \ y = x ⊓ yᶜ) -} = sdiff_eq + , himp_eq {- (∀ (x y : α), x ⇨ y = y ⊔ xᶜ) -} = himp_eq + } diff --git a/Documentation/SBV/Examples/KnuckleDragger/Sqrt2IsIrrational.hs b/Documentation/SBV/Examples/KnuckleDragger/Sqrt2IsIrrational.hs --- a/Documentation/SBV/Examples/KnuckleDragger/Sqrt2IsIrrational.hs +++ b/Documentation/SBV/Examples/KnuckleDragger/Sqrt2IsIrrational.hs @@ -13,7 +13,7 @@ {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TypeAbstractions #-} -{-# OPTIONS_GHC -Wall -Werror -Wno-unused-matches #-} +{-# OPTIONS_GHC -Wall -Werror #-} module Documentation.SBV.Examples.KnuckleDragger.Sqrt2IsIrrational where @@ -48,14 +48,15 @@ -- We have: -- -- >>> sqrt2IsIrrational --- Chain: oddSquaredIsOdd --- Lemma: oddSquaredIsOdd.1 Q.E.D. --- Lemma: oddSquaredIsOdd.2 Q.E.D. --- Lemma: oddSquaredIsOdd Q.E.D. +-- Lemma: oddSquaredIsOdd +-- Asms : 1 Q.E.D. +-- Step : 1 Q.E.D. +-- Result: Q.E.D. -- Lemma: squareEvenImpliesEven Q.E.D. --- Chain: evenSquaredIsMult4 --- Lemma: evenSquaredIsMult4.1 Q.E.D. --- Lemma: evenSquaredIsMult4 Q.E.D. +-- Lemma: evenSquaredIsMult4 +-- Asms : 1 Q.E.D. +-- Step : 1 Q.E.D. +-- Result: Q.E.D. -- Lemma: sqrt2IsIrrational Q.E.D. -- [Proven] sqrt2IsIrrational sqrt2IsIrrational :: IO Proof @@ -74,14 +75,11 @@ -- Interestingly, the solver doesn't need the analogous theorem that even number -- squared is even, possibly because the even/odd definition above is enough for -- it to deduce that fact automatically. - oddSquaredIsOdd <- chainLemma "oddSquaredIsOdd" - (\(Forall @"a" a) -> odd a .=> odd (sq a)) - (\a -> let k = a `sDiv` 2 - in [ odd a - , sq a .== sq (2 * k + 1) - , a .== 2 * k + 1 - ]) - [] + oddSquaredIsOdd <- calc "oddSquaredIsOdd" + (\(Forall @"a" a) -> odd a .=> odd (sq a)) $ + \a -> [odd a] |- sq a ? odd a + =: sq (2 * ((a-1) `sEDiv` 2) + 1) + =: qed -- Prove that if a perfect square is even, then it be the square of an even number. For z3, the above proof -- is enough to establish this. @@ -90,14 +88,11 @@ [oddSquaredIsOdd] -- Prove that if @a@ is an even number, then its square is four times the square of another. - -- Happily, z3 needs nchainLemma helpers to establish this all on its own. - evenSquaredIsMult4 <- chainLemma "evenSquaredIsMult4" - (\(Forall @"a" a) -> even a .=> 4 `sDivides` sq a) - (\a -> let k = a `sDiv` 2 - in [ even a - , sq a .== sq (k * 2) - ]) - [] + evenSquaredIsMult4 <- calc "evenSquaredIsMult4" + (\(Forall @"a" a) -> even a .=> 4 `sDivides` sq a) $ + \a -> [even a] |- sq a ? even a + =: sq (2 * (a `sEDiv` 2)) + =: qed -- Define what it means to be co-prime. Note that we use euclidian notion of modulus here -- as z3 deals with that much better. Two numbers are co-prime if 1 is their only common divisor. @@ -107,5 +102,5 @@ -- Prove that square-root of 2 is irrational. We do this by showing for all pairs of integers @a@ and @b@ -- such that @a*a == 2*b*b@, it must be the case that @a@ and @b@ are not be co-prime: lemma "sqrt2IsIrrational" - (\(Forall @"a" a) (Forall @"b" b) -> ((sq a .== 2 * sq b) .=> sNot (coPrime a b))) + (\(Forall @"a" a) (Forall @"b" b) -> (sq a .== 2 * sq b) .=> sNot (coPrime a b)) [squareEvenImpliesEven, evenSquaredIsMult4] diff --git a/Documentation/SBV/Examples/Lists/BoundedMutex.hs b/Documentation/SBV/Examples/Lists/BoundedMutex.hs --- a/Documentation/SBV/Examples/Lists/BoundedMutex.hs +++ b/Documentation/SBV/Examples/Lists/BoundedMutex.hs @@ -6,8 +6,7 @@ -- Maintainer: erkokl@gmail.com -- Stability : experimental -- --- Demonstrates use of bounded list utilities, proving a simple --- mutex algorithm correct up to given bounds. +-- Proves a simple mutex algorithm correct up to a given bound. ----------------------------------------------------------------------------- {-# LANGUAGE DeriveAnyClass #-} @@ -27,8 +26,7 @@ import Prelude hiding ((!!)) import Data.SBV.List ((!!)) -import qualified Data.SBV.List as L -import qualified Data.SBV.Tools.BoundedList as L +import qualified Data.SBV.List as L -- | Each agent can be in one of the three states data State = Idle -- ^ Regular work @@ -38,10 +36,10 @@ -- | Make 'State' a symbolic enumeration mkSymbolicEnumeration ''State --- | A bounded mutex property holds for two sequences of state transitions, if they are not in --- their critical section at the same time up to that given bound. -mutex :: Int -> SList State -> SList State -> SBool -mutex i p1s p2s = L.band i $ L.bzipWith i (\p1 p2 -> p1 ./= sCritical .|| p2 ./= sCritical) p1s p2s +-- | The mutex property holds for two sequences of state transitions, if they are not in +-- their critical section at the same time. +mutex :: SList State -> SList State -> SBool +mutex p1s p2s = L.and $ L.zipWith (\p1 p2 -> p1 ./= sCritical .|| p2 ./= sCritical) p1s p2s -- | A sequence is valid upto a bound if it starts at 'Idle', and follows the mutex rules. That is: -- @@ -100,7 +98,7 @@ -- Try to assert that mutex does not hold. If we get a -- counter example, we would've found a violation! - constrain $ sNot $ mutex b p1 p2 + constrain $ sNot $ mutex p1 p2 query $ do cs <- checkSat case cs of @@ -121,11 +119,11 @@ -- trying to show a bounded trace of length 10, such that the second process is ready but -- never transitions to critical. We have: -- --- > ghci> notFair 10 --- > Fairness is violated at bound: 10 --- > P1: [Idle,Idle,Ready,Critical,Idle,Idle,Ready,Critical,Idle,Idle] --- > P2: [Idle,Ready,Ready,Ready,Ready,Ready,Ready,Ready,Ready,Ready] --- > Ts: [1,2,1,1,1,1,1,1,1,1] +-- >>> notFair 10 +-- Fairness is violated at bound: 10 +-- P1: [Idle,Idle,Idle,Ready,Critical,Critical,Critical,Idle,Ready,Critical] +-- P2: [Idle,Ready,Ready,Ready,Ready,Ready,Ready,Ready,Ready,Ready] +-- Ts: [1,1,1,1,1,1,1,1,1,1] -- -- As expected, P2 gets ready but never goes critical since the arbiter keeps picking -- P1 unfairly. (You might get a different trace depending on what z3 happens to produce!) @@ -148,7 +146,7 @@ -- Find a trace where p2 never goes critical -- counter example, we would've found a violation! - constrain $ sNot $ L.belem b sCritical p2 + constrain $ sNot $ sCritical `L.elem` p2 query $ do cs <- checkSat case cs of 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 @@ -42,9 +42,9 @@ -- Solution #1: -- s0 = C :: E -- Solution #2: --- s0 = B :: E --- Solution #3: -- s0 = A :: E +-- Solution #3: +-- s0 = B :: E -- Found 3 different solutions. elts :: IO AllSatResult elts = allSat $ \(x::SE) -> x .== x diff --git a/Documentation/SBV/Examples/Misc/FirstOrderLogic.hs b/Documentation/SBV/Examples/Misc/FirstOrderLogic.hs --- a/Documentation/SBV/Examples/Misc/FirstOrderLogic.hs +++ b/Documentation/SBV/Examples/Misc/FirstOrderLogic.hs @@ -137,8 +137,8 @@ P _ = False Q :: U -> Bool - Q U_0 = False Q U_2 = False + Q U_0 = False Q _ = True The solver found us a falsifying instance: Pick a domain with at least three elements. We'll call diff --git a/Documentation/SBV/Examples/Misc/Floating.hs b/Documentation/SBV/Examples/Misc/Floating.hs --- a/Documentation/SBV/Examples/Misc/Floating.hs +++ b/Documentation/SBV/Examples/Misc/Floating.hs @@ -69,19 +69,19 @@ -- -- >>> assocPlusRegular -- Falsifiable. Counter-example: --- x = 4.4272205e21 :: Float --- y = 2.9514347e20 :: Float --- z = 4.4676022e15 :: Float +-- x = 1.9258643e-34 :: Float +-- y = -1.925931e-34 :: Float +-- z = -3.8518585e-34 :: Float -- -- Indeed, we have: -- --- >>> let x = 4.4272205e21 :: Float --- >>> let y = 2.9514347e20 :: Float --- >>> let z = 4.4676022e15 :: Float +-- >>> let x = 1.9258643e-34 :: Float +-- >>> let y = -1.925931e-34 :: Float +-- >>> let z = -3.8518585e-34 :: Float -- >>> x + (y + z) --- 4.722369e21 +-- -3.8519256e-34 -- >>> (x + y) + z --- 4.722368e21 +-- -3.851925e-34 -- -- Note the significant difference in the results! assocPlusRegular :: IO ThmResult @@ -132,11 +132,11 @@ -- -- >>> multInverse -- Falsifiable. Counter-example: --- a = -1.4991268e38 :: Float +-- a = -1.0669042e-38 :: Float -- -- Indeed, we have: -- --- >>> let a = -1.4991268e38 :: Float +-- >>> let a = -1.0669042e-38 :: Float -- >>> a * (1/a) -- 0.99999994 multInverse :: IO ThmResult diff --git a/Documentation/SBV/Examples/Misc/LambdaArray.hs b/Documentation/SBV/Examples/Misc/LambdaArray.hs --- a/Documentation/SBV/Examples/Misc/LambdaArray.hs +++ b/Documentation/SBV/Examples/Misc/LambdaArray.hs @@ -45,12 +45,12 @@ -- -- >>> outOfInit -- Satisfiable. Model: --- Read = 1 :: Integer -- mem = ([], 1) :: Array Integer Integer -- lo = 0 :: Integer -- hi = 0 :: Integer -- zero = 0 :: Integer -- idx = 1 :: Integer +-- Read = 1 :: Integer outOfInit :: IO SatResult outOfInit = sat $ do mem <- sArray "mem" diff --git a/Documentation/SBV/Examples/Optimization/Enumerate.hs b/Documentation/SBV/Examples/Optimization/Enumerate.hs --- a/Documentation/SBV/Examples/Optimization/Enumerate.hs +++ b/Documentation/SBV/Examples/Optimization/Enumerate.hs @@ -63,9 +63,9 @@ -- -- >>> almostWeekend -- Optimal model: --- last-day = Fri :: Day -- almostWeekend = Fri :: Day -- DayAsWord8(last-day) = 4 :: Word8 +-- last-day = Fri :: Day almostWeekend :: IO OptimizeResult almostWeekend = optimize Lexicographic $ do day <- free "almostWeekend" @@ -77,9 +77,9 @@ -- -- >>> weekendJustOver -- Optimal model: --- first-day = Mon :: Day -- weekendJustOver = Mon :: Day -- DayAsWord8(first-day) = 0 :: Word8 +-- first-day = Mon :: Day weekendJustOver :: IO OptimizeResult weekendJustOver = optimize Lexicographic $ do day <- free "weekendJustOver" @@ -91,9 +91,9 @@ -- -- >>> firstWeekend -- Optimal model: --- first-weekend = Sat :: Day -- firstWeekend = Sat :: Day -- DayAsWord8(first-weekend) = 5 :: Word8 +-- first-weekend = Sat :: Day firstWeekend :: IO OptimizeResult firstWeekend = optimize Lexicographic $ do day <- free "firstWeekend" diff --git a/Documentation/SBV/Examples/ProofTools/BMC.hs b/Documentation/SBV/Examples/ProofTools/BMC.hs --- a/Documentation/SBV/Examples/ProofTools/BMC.hs +++ b/Documentation/SBV/Examples/ProofTools/BMC.hs @@ -82,7 +82,7 @@ -- BMC Cover: Iteration: 2 -- BMC Cover: Iteration: 3 -- BMC Cover: Satisfying state found at iteration 3 --- Right (3,[(0,10),(0,6),(0,2),(2,2)]) +-- Right (3,[(0,10),(0,6),(2,6),(2,2)]) -- -- As expected, there's a solution in this case. Furthermore, since the BMC engine -- found a solution at depth @3@, we also know that there is no solution at diff --git a/Documentation/SBV/Examples/Puzzles/AOC_2021_24.hs b/Documentation/SBV/Examples/Puzzles/AOC_2021_24.hs --- a/Documentation/SBV/Examples/Puzzles/AOC_2021_24.hs +++ b/Documentation/SBV/Examples/Puzzles/AOC_2021_24.hs @@ -20,10 +20,15 @@ -- should provide a template for other similar programs. ----------------------------------------------------------------------------- +{-# LANGUAGE CPP #-} {-# LANGUAGE NamedFieldPuns #-} {-# LANGUAGE NegativeLiterals #-} +#if __GLASGOW_HASKELL__ >= 913 +{-# OPTIONS_GHC -Wall -Werror -Wno-incomplete-record-selectors #-} +#else {-# OPTIONS_GHC -Wall -Werror #-} +#endif module Documentation.SBV.Examples.Puzzles.AOC_2021_24 where diff --git a/Documentation/SBV/Examples/Puzzles/HexPuzzle.hs b/Documentation/SBV/Examples/Puzzles/HexPuzzle.hs --- a/Documentation/SBV/Examples/Puzzles/HexPuzzle.hs +++ b/Documentation/SBV/Examples/Puzzles/HexPuzzle.hs @@ -41,6 +41,7 @@ {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE StandaloneDeriving #-} {-# LANGUAGE TemplateHaskell #-} +{-# LANGUAGE TypeApplications #-} {-# OPTIONS_GHC -Wall -Werror #-} @@ -49,6 +50,8 @@ import Data.SBV import Data.SBV.Control +import Data.Proxy + -- | Colors we're allowed data Color = Black | Blue | Green | Red @@ -83,7 +86,7 @@ -- | Iteratively search at increasing depths of button-presses to see if we can -- transform from the initial board position to a final board position. search :: [Color] -> [Color] -> IO () -search initial final = runSMT $ do registerUISMTFunction (uninterpret "unused_" :: SColor -> SColor) +search initial final = runSMT $ do registerType (Proxy @SColor) let emptyGrid = lambdaArray (const sBlack) initGrid = foldr (\(i, c) a -> writeArray a (literal i) (literal c)) emptyGrid (zip [1..] initial) query $ loop (0 :: Int) initGrid [] diff --git a/Documentation/SBV/Examples/Puzzles/Murder.hs b/Documentation/SBV/Examples/Puzzles/Murder.hs --- a/Documentation/SBV/Examples/Puzzles/Murder.hs +++ b/Documentation/SBV/Examples/Puzzles/Murder.hs @@ -34,7 +34,7 @@ import Data.Char import Data.List -import Data.SBV +import Data.SBV hiding (some) import Data.SBV.Control -- | Locations @@ -86,10 +86,10 @@ -- | Solve the puzzle. We have: -- -- >>> killer --- Alice 48 Bar Female Bystander --- Husband 47 Beach Male Killer --- Brother 48 Beach Male Victim --- Daughter 21 Alone Female Bystander +-- Alice 47 Bar Female Bystander +-- Husband 46 Beach Male Killer +-- Brother 47 Beach Male Victim +-- Daughter 20 Alone Female Bystander -- Son 20 Bar Male Bystander -- -- That is, Alice's brother was the victim and Alice's husband was the killer. @@ -138,8 +138,8 @@ let ifVictim p = role p .== sVictim ifKiller p = role p .== sKiller - every f = sAnd (map f chars) - some f = sOr (map f chars) + every f = sAll f chars + some f = sAny f chars -- A man and a woman were together in a bar at the time of the murder. constrain $ some $ \c -> sex c .== sFemale .&& location c .== sBar @@ -177,3 +177,5 @@ s <- getPerson son pure [a, h, b, d, s] _ -> error $ "Solver said: " ++ show cs + +{- HLint ignore getPerson "Functor law" -} diff --git a/Documentation/SBV/Examples/Puzzles/Sudoku.hs b/Documentation/SBV/Examples/Puzzles/Sudoku.hs --- a/Documentation/SBV/Examples/Puzzles/Sudoku.hs +++ b/Documentation/SBV/Examples/Puzzles/Sudoku.hs @@ -65,7 +65,7 @@ -- | Fill a given board, replacing 0's with appropriate elements to solve the puzzle fillBoard :: Puzzle -> IO Puzzle fillBoard board = runSMT $ do - let emptyCellCount = length $ filter (== 0) $ concat board + let emptyCellCount = length $ concatMap (filter (== 0)) board subst <- mkFreeVars emptyCellCount constrain $ valid (fill literal subst) diff --git a/Documentation/SBV/Examples/Queries/Abducts.hs b/Documentation/SBV/Examples/Queries/Abducts.hs --- a/Documentation/SBV/Examples/Queries/Abducts.hs +++ b/Documentation/SBV/Examples/Queries/Abducts.hs @@ -22,10 +22,10 @@ -- and we want to make @x + y >= 2@. We have: -- -- >>> example --- Got: (define-fun abd () Bool (and (= s0 s1) (= s0 1))) --- Got: (define-fun abd () Bool (and (= 2 s1) (= s0 1))) --- Got: (define-fun abd () Bool (and (= s0 s1) (<= 1 s1))) --- Got: (define-fun abd () Bool (= 2 s1)) +-- Got: (define-fun abd () Bool (= s1 2)) +-- Got: (define-fun abd () Bool (and (= s1 1) (<= s1 s0))) +-- Got: (define-fun abd () Bool (and (<= 1 s0) (= s1 s0))) +-- Got: (define-fun abd () Bool (and (<= s1 (+ s0 s0)) (<= 1 s1))) -- -- Note that @s0@ refers to @x@ and @s1@ refers to @y@ above. You can verify -- that adding any of these will ensure @x + y >= 2@. diff --git a/Documentation/SBV/Examples/Queries/AllSat.hs b/Documentation/SBV/Examples/Queries/AllSat.hs --- a/Documentation/SBV/Examples/Queries/AllSat.hs +++ b/Documentation/SBV/Examples/Queries/AllSat.hs @@ -10,7 +10,7 @@ -- solver repeatedly, telling it to give us a new model each time. SBV already -- provides 'Data.SBV.allSat' that precisely does this. However, this example demonstrates -- how the query mode can be used to achieve the same, and can also incorporate --- extra conditions with easy as we walk through solutions. +-- extra conditions with ease as we walk through solutions. ----------------------------------------------------------------------------- {-# OPTIONS_GHC -Wall -Werror #-} diff --git a/LICENSE b/LICENSE --- a/LICENSE +++ b/LICENSE @@ -1,6 +1,6 @@ SBV: SMT Based Verification in Haskell -Copyright (c) 2010-2024, Levent Erkok (erkokl@gmail.com) +Copyright (c) 2010-2025, Levent Erkok (erkokl@gmail.com) All rights reserved. Redistribution and use in source and binary forms, with or without diff --git a/README.md b/README.md --- a/README.md +++ b/README.md @@ -147,6 +147,7 @@ Sirui Lu, Georgy Lukyanov, Martin Lundfall, +Daniel Matichuk, John Matthews, Curran McConnell, Philipp Meyer, @@ -161,6 +162,7 @@ Gleb Popov, Rohit Ramesh, Geoffrey Ramseyer, +Blake C. Rawlings, Jaro Reinders, Stephan Renatus, Dan Rosén, diff --git a/SBVTestSuite/GoldFiles/allSat7.gold b/SBVTestSuite/GoldFiles/allSat7.gold --- a/SBVTestSuite/GoldFiles/allSat7.gold +++ b/SBVTestSuite/GoldFiles/allSat7.gold @@ -579,33890 +579,33890 @@ [SEND] (get-value (s1)) [RECV] ((s1 1)) [SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 42 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 43 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 44 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 45 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 46 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 47 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 48 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 49 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 50 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 51 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 52 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 53 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s72) -[GOOD] (define-fun s74 () Bool (= s1 s18)) -[GOOD] (assert s74) -Fast allSat, Looking for solution 53 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 54 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 55 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 56 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 57 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 58 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 59 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 60 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 61 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 62 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 63 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 64 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 65 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s72) -[GOOD] (define-fun s75 () Bool (= s1 s16)) -[GOOD] (assert s75) -Fast allSat, Looking for solution 65 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 66 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 67 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 68 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 69 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 70 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 71 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 72 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 73 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 74 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 75 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 76 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 77 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s72) -[GOOD] (define-fun s76 () Bool (= s1 s20)) -[GOOD] (assert s76) -Fast allSat, Looking for solution 77 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 78 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 79 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 80 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 81 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 82 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 83 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 84 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 85 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 86 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 87 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 88 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 89 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s72) -[GOOD] (define-fun s77 () Bool (= s1 s22)) -[GOOD] (assert s77) -Fast allSat, Looking for solution 89 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 90 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 91 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 92 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 93 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 94 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 95 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 96 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 97 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 98 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 99 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 100 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 101 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s72) -[GOOD] (define-fun s78 () Bool (= s1 s24)) -[GOOD] (assert s78) -Fast allSat, Looking for solution 101 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 102 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 103 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 104 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 105 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 106 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 107 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 108 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 109 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 110 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 111 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 112 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 113 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s72) -[GOOD] (define-fun s79 () Bool (= s1 s26)) -[GOOD] (assert s79) -Fast allSat, Looking for solution 113 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 114 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 115 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 116 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 117 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 118 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 119 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 120 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 121 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 122 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 123 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 124 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 125 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s72) -[GOOD] (define-fun s80 () Bool (= s1 s28)) -[GOOD] (assert s80) -Fast allSat, Looking for solution 125 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 126 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 127 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 128 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 129 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 130 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 131 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 132 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 133 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 134 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 135 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 136 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 137 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s72) -[GOOD] (define-fun s81 () Bool (= s1 s30)) -[GOOD] (assert s81) -Fast allSat, Looking for solution 137 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 138 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 139 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 140 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 141 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 142 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 143 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 144 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 145 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 146 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 147 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 148 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 149 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s72) -[GOOD] (define-fun s82 () Bool (= s1 s32)) -[GOOD] (assert s82) -Fast allSat, Looking for solution 149 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 150 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 151 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 152 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 153 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 154 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 155 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 156 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 157 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 158 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 159 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 160 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 161 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s72) -[GOOD] (define-fun s83 () Bool (= s1 s34)) -[GOOD] (assert s83) -Fast allSat, Looking for solution 161 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 162 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 163 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 164 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 165 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 166 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 167 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 168 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 169 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 170 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 171 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 172 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 173 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s72) -[GOOD] (define-fun s84 () Bool (= s1 s36)) -[GOOD] (assert s84) -Fast allSat, Looking for solution 173 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 174 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 175 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 176 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 177 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 178 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 179 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 180 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 181 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 182 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 183 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 184 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 185 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s72) -[GOOD] (assert s44) -[GOOD] (define-fun s85 () Bool (= s1 s38)) -[GOOD] (assert s85) -Fast allSat, Looking for solution 185 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 186 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 187 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 188 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 189 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 190 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 191 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 192 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 193 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 194 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 195 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 196 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 197 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s43) -[GOOD] (define-fun s86 () Bool (= s0 s40)) -[GOOD] (assert s86) -Fast allSat, Looking for solution 197 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s45) -Fast allSat, Looking for solution 198 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s46) -Fast allSat, Looking for solution 199 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s47) -Fast allSat, Looking for solution 200 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s48) -Fast allSat, Looking for solution 201 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s49) -Fast allSat, Looking for solution 202 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s50) -Fast allSat, Looking for solution 203 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s51) -Fast allSat, Looking for solution 204 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s52) -Fast allSat, Looking for solution 205 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s53) -Fast allSat, Looking for solution 206 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s54) -Fast allSat, Looking for solution 207 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s55) -Fast allSat, Looking for solution 208 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s56) -Fast allSat, Looking for solution 209 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (define-fun s87 () Bool (distinct s1 s5)) -[GOOD] (assert s87) -Fast allSat, Looking for solution 210 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s58) -[GOOD] (define-fun s88 () Bool (= s1 s5)) -[GOOD] (assert s88) -Fast allSat, Looking for solution 210 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 211 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 212 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 213 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 214 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 215 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 216 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 217 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 218 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 219 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 220 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 221 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 222 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s70) -[GOOD] (assert s73) -Fast allSat, Looking for solution 222 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 223 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 224 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 225 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 226 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 227 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 228 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 229 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 230 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 231 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 232 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 233 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (define-fun s89 () Bool (distinct s2 s5)) -[GOOD] (assert s89) -Fast allSat, Looking for solution 234 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s71) -[GOOD] (assert s74) -Fast allSat, Looking for solution 234 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 235 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 236 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 237 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 238 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 239 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 240 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 241 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 242 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 243 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 244 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 245 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 246 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s70) -[GOOD] (assert s75) -Fast allSat, Looking for solution 246 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 247 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 248 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 249 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 250 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 251 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 252 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 253 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 254 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 255 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 256 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 257 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 258 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s69) -[GOOD] (assert s76) -Fast allSat, Looking for solution 258 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 259 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 260 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 261 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 262 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 263 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 264 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 265 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 266 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 267 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 268 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 269 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 270 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s68) -[GOOD] (assert s77) -Fast allSat, Looking for solution 270 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 271 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 272 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 273 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 274 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 275 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 276 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 277 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 278 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 279 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 280 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 281 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 282 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s67) -[GOOD] (assert s78) -Fast allSat, Looking for solution 282 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 283 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 284 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 285 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 286 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 287 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 288 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 289 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 290 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 291 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 292 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 293 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 294 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s66) -[GOOD] (assert s79) -Fast allSat, Looking for solution 294 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 295 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 296 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 297 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 298 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 299 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 300 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 301 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 302 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 303 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 304 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 305 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 306 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s65) -[GOOD] (assert s80) -Fast allSat, Looking for solution 306 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 307 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 308 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 309 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 310 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 311 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 312 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 313 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 314 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 315 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 316 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 317 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 318 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s64) -[GOOD] (assert s81) -Fast allSat, Looking for solution 318 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 319 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 320 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 321 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 322 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 323 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 324 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 325 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 326 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 327 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 328 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 329 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 330 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s63) -[GOOD] (assert s82) -Fast allSat, Looking for solution 330 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 331 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 332 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 333 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 334 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 335 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 336 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 337 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 338 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 339 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 340 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 341 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 342 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s62) -[GOOD] (assert s83) -Fast allSat, Looking for solution 342 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 343 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 344 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 345 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 346 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 347 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 348 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 349 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 350 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 351 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 352 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 353 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 354 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s61) -[GOOD] (assert s84) -Fast allSat, Looking for solution 354 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 355 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 356 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 357 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 358 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 359 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 360 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 361 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 362 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 363 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 364 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 365 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 366 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s86) -[GOOD] (assert s85) -Fast allSat, Looking for solution 366 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 367 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 368 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 369 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 370 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 371 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 372 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 373 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 374 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 375 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 376 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 377 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 378 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s45) -[GOOD] (define-fun s90 () Bool (= s0 s38)) -[GOOD] (assert s90) -Fast allSat, Looking for solution 378 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s46) -Fast allSat, Looking for solution 379 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s47) -Fast allSat, Looking for solution 380 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s48) -Fast allSat, Looking for solution 381 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s49) -Fast allSat, Looking for solution 382 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s50) -Fast allSat, Looking for solution 383 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s51) -Fast allSat, Looking for solution 384 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s52) -Fast allSat, Looking for solution 385 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s53) -Fast allSat, Looking for solution 386 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s54) -Fast allSat, Looking for solution 387 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s55) -Fast allSat, Looking for solution 388 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s57) -Fast allSat, Looking for solution 389 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s87) -Fast allSat, Looking for solution 390 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s56) -Fast allSat, Looking for solution 391 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s60) -[GOOD] (assert s73) -Fast allSat, Looking for solution 391 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 392 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 393 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 394 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 395 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 396 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 397 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 398 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 399 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 400 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 401 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 402 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 403 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s60) -[GOOD] (assert s88) -Fast allSat, Looking for solution 403 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 404 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 405 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 406 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 407 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 408 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 409 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 410 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 411 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 412 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 413 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 414 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 415 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s60) -[GOOD] (assert s59) -Fast allSat, Looking for solution 415 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 416 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 417 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 418 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 419 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 420 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 421 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 422 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 423 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 424 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 425 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 426 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 427 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s71) -[GOOD] (assert s74) -Fast allSat, Looking for solution 427 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 428 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 429 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 430 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 431 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 432 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 433 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 434 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 435 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 436 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 437 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 438 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 439 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s70) -[GOOD] (assert s75) -Fast allSat, Looking for solution 439 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 440 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 441 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 442 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 443 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 444 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 445 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 446 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 447 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 448 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 449 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 450 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 451 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s69) -[GOOD] (assert s76) -Fast allSat, Looking for solution 451 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 452 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 453 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 454 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 455 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 456 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 457 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 458 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 459 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 460 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 461 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 462 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 463 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s68) -[GOOD] (assert s77) -Fast allSat, Looking for solution 463 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 464 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 465 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 466 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 467 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 468 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 469 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 470 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 471 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 472 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 473 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 474 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 475 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s67) -[GOOD] (assert s78) -Fast allSat, Looking for solution 475 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 476 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 477 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 478 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 479 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 480 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 481 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 482 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 483 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 484 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 485 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 486 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 487 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s66) -[GOOD] (assert s79) -Fast allSat, Looking for solution 487 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 488 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 489 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 490 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 491 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 492 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 493 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 494 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 495 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 496 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 497 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 498 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 499 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s65) -[GOOD] (assert s80) -Fast allSat, Looking for solution 499 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 500 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 501 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 502 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 503 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 504 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 505 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 506 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 507 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 508 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 509 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 510 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 511 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s64) -[GOOD] (assert s81) -Fast allSat, Looking for solution 511 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 512 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 513 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 514 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 515 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 516 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 517 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 518 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 519 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 520 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 521 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 522 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 523 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s63) -[GOOD] (assert s82) -Fast allSat, Looking for solution 523 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 524 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 525 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 526 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 527 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 528 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 529 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 530 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 531 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 532 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 533 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 534 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 535 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s62) -[GOOD] (assert s83) -Fast allSat, Looking for solution 535 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 536 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 537 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 538 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 539 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 540 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 541 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 542 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 543 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 544 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 545 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 546 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 547 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s72) -[GOOD] (assert s90) -[GOOD] (assert s84) -Fast allSat, Looking for solution 547 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 548 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 549 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 550 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 551 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 552 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 553 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 554 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 555 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 556 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 557 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 558 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 559 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s46) -[GOOD] (define-fun s91 () Bool (= s0 s36)) -[GOOD] (assert s91) -Fast allSat, Looking for solution 559 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s47) -Fast allSat, Looking for solution 560 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s48) -Fast allSat, Looking for solution 561 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s49) -Fast allSat, Looking for solution 562 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s50) -Fast allSat, Looking for solution 563 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s51) -Fast allSat, Looking for solution 564 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s52) -Fast allSat, Looking for solution 565 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s53) -Fast allSat, Looking for solution 566 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s54) -Fast allSat, Looking for solution 567 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s55) -Fast allSat, Looking for solution 568 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s56) -Fast allSat, Looking for solution 569 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s43) -Fast allSat, Looking for solution 570 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s57) -Fast allSat, Looking for solution 571 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s87) -Fast allSat, Looking for solution 572 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s61) -[GOOD] (assert s88) -Fast allSat, Looking for solution 572 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 573 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 574 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 575 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 576 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 577 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 578 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 579 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 580 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 581 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 582 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 583 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 584 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s59) -Fast allSat, Looking for solution 584 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 585 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 586 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 587 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 588 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 589 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 590 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 591 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 592 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 593 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 594 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 595 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 596 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s85) -Fast allSat, Looking for solution 596 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 597 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 598 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 599 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 600 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 601 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 602 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 603 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 604 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 605 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 606 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 607 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 608 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s73) -Fast allSat, Looking for solution 608 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 609 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 610 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 611 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 612 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 613 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 614 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 615 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 616 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 617 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 618 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 619 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 620 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s74) -Fast allSat, Looking for solution 620 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 621 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 622 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 623 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 624 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 625 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 626 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 627 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 628 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 629 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 630 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 631 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 632 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s75) -Fast allSat, Looking for solution 632 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 633 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 634 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 635 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 636 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 637 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 638 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 639 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 640 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 641 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 642 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 643 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 644 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s76) -Fast allSat, Looking for solution 644 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 645 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 646 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 647 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 648 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 649 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 650 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 651 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 652 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 653 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 654 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 655 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 656 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s77) -Fast allSat, Looking for solution 656 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 657 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 658 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 659 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 660 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 661 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 662 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 663 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 664 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 665 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 666 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 667 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 668 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s78) -Fast allSat, Looking for solution 668 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 669 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 670 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 671 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 672 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 673 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 674 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 675 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 676 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 677 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 678 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 679 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 680 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s79) -Fast allSat, Looking for solution 680 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 681 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 682 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 683 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 684 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 685 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 686 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 687 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 688 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 689 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 690 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 691 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 692 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s80) -Fast allSat, Looking for solution 692 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 693 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 694 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 695 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 696 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 697 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 698 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 699 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 700 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 701 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 702 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 703 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 704 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s81) -Fast allSat, Looking for solution 704 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 705 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 706 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 707 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 708 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 709 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 710 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 711 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 712 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 713 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 714 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 715 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 716 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s82) -Fast allSat, Looking for solution 716 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 717 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 718 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 719 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 720 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 721 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 722 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 723 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 724 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 725 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 726 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 727 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 728 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s58) -[GOOD] (assert s91) -[GOOD] (assert s83) -Fast allSat, Looking for solution 728 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 729 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 730 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 731 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 732 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 733 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 734 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 735 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 736 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 737 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 738 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 739 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 740 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s47) -[GOOD] (define-fun s92 () Bool (= s0 s34)) -[GOOD] (assert s92) -Fast allSat, Looking for solution 740 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s48) -Fast allSat, Looking for solution 741 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s49) -Fast allSat, Looking for solution 742 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s50) -Fast allSat, Looking for solution 743 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s51) -Fast allSat, Looking for solution 744 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s52) -Fast allSat, Looking for solution 745 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s53) -Fast allSat, Looking for solution 746 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s54) -Fast allSat, Looking for solution 747 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s55) -Fast allSat, Looking for solution 748 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s45) -Fast allSat, Looking for solution 749 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s43) -Fast allSat, Looking for solution 750 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s57) -Fast allSat, Looking for solution 751 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s87) -Fast allSat, Looking for solution 752 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s56) -Fast allSat, Looking for solution 753 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s62) -[GOOD] (assert s73) -Fast allSat, Looking for solution 753 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 754 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 755 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 756 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 757 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 758 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 759 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 760 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 761 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 762 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 763 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 764 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 765 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s62) -[GOOD] (assert s88) -Fast allSat, Looking for solution 765 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 766 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 767 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 768 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 769 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 770 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 771 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 772 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 773 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 774 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 775 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 776 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 777 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s62) -[GOOD] (assert s59) -Fast allSat, Looking for solution 777 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 778 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 779 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 780 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 781 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 782 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 783 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 784 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 785 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 786 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 787 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 788 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 789 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s62) -[GOOD] (assert s85) -Fast allSat, Looking for solution 789 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 790 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 791 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 792 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 793 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 794 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 795 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 796 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 797 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 798 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 799 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 800 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 801 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s62) -[GOOD] (assert s84) -Fast allSat, Looking for solution 801 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 802 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 803 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 804 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 805 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 806 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 807 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 808 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 809 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 810 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 811 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 812 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 813 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s71) -[GOOD] (assert s74) -Fast allSat, Looking for solution 813 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 814 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 815 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 816 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 817 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 818 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 819 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 820 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 821 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 822 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 823 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 824 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 825 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s70) -[GOOD] (assert s75) -Fast allSat, Looking for solution 825 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 826 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 827 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 828 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 829 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 830 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 831 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 832 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 833 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 834 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 835 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 836 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 837 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s69) -[GOOD] (assert s76) -Fast allSat, Looking for solution 837 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 838 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 839 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 840 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 841 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 842 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 843 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 844 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 845 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 846 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 847 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 848 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 849 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s68) -[GOOD] (assert s77) -Fast allSat, Looking for solution 849 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 850 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 851 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 852 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 853 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 854 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 855 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 856 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 857 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 858 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 859 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 860 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 861 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s67) -[GOOD] (assert s78) -Fast allSat, Looking for solution 861 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 862 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 863 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 864 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 865 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 866 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 867 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 868 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 869 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 870 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 871 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 872 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 873 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s66) -[GOOD] (assert s79) -Fast allSat, Looking for solution 873 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 874 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 875 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 876 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 877 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 878 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 879 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 880 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 881 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 882 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 883 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 884 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 885 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s65) -[GOOD] (assert s80) -Fast allSat, Looking for solution 885 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 886 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 887 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 888 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 889 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 890 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 891 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 892 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 893 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 894 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 895 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 896 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 897 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s64) -[GOOD] (assert s81) -Fast allSat, Looking for solution 897 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 898 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 899 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 900 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 901 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 902 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 903 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 904 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 905 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 906 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 907 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 908 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 909 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s60) -[GOOD] (assert s92) -[GOOD] (assert s82) -Fast allSat, Looking for solution 909 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 910 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 911 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 912 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 913 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 914 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 915 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 916 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 917 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 918 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 919 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 920 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 921 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s48) -[GOOD] (define-fun s93 () Bool (= s0 s32)) -[GOOD] (assert s93) -Fast allSat, Looking for solution 921 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s49) -Fast allSat, Looking for solution 922 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s50) -Fast allSat, Looking for solution 923 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s51) -Fast allSat, Looking for solution 924 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s52) -Fast allSat, Looking for solution 925 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s53) -Fast allSat, Looking for solution 926 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s54) -Fast allSat, Looking for solution 927 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s55) -Fast allSat, Looking for solution 928 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s56) -Fast allSat, Looking for solution 929 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s46) -Fast allSat, Looking for solution 930 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s45) -Fast allSat, Looking for solution 931 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s43) -Fast allSat, Looking for solution 932 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s57) -Fast allSat, Looking for solution 933 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s87) -Fast allSat, Looking for solution 934 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s72) -[GOOD] (assert s88) -Fast allSat, Looking for solution 934 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 935 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 936 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 937 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 938 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 939 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 940 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 941 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 942 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 943 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 944 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 945 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 946 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s59) -Fast allSat, Looking for solution 946 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 947 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 948 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 949 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 950 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 951 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 952 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 953 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 954 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 955 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 956 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 957 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 958 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s85) -Fast allSat, Looking for solution 958 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 959 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 960 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 961 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 962 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 963 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 964 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 965 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 966 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 967 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 968 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 969 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 970 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s84) -Fast allSat, Looking for solution 970 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 971 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 972 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 973 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 974 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 975 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 976 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 977 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 978 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 979 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 980 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 981 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 982 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s83) -Fast allSat, Looking for solution 982 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 983 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 984 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 985 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 986 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 987 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 988 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 989 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 990 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 991 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 992 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 993 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 994 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s73) -Fast allSat, Looking for solution 994 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 995 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 996 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 997 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 998 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 999 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1000 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1001 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1002 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1003 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1004 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1005 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1006 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s74) -Fast allSat, Looking for solution 1006 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1007 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1008 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1009 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1010 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1011 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1012 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1013 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1014 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1015 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1016 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1017 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1018 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s75) -Fast allSat, Looking for solution 1018 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1019 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1020 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1021 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1022 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1023 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1024 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1025 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1026 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1027 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1028 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1029 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1030 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s76) -Fast allSat, Looking for solution 1030 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1031 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1032 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1033 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1034 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1035 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1036 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1037 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1038 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1039 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1040 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1041 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1042 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s77) -Fast allSat, Looking for solution 1042 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1043 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1044 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1045 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1046 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1047 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1048 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1049 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1050 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1051 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1052 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1053 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1054 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s78) -Fast allSat, Looking for solution 1054 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1055 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1056 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1057 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1058 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1059 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1060 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1061 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1062 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1063 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1064 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1065 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1066 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s79) -Fast allSat, Looking for solution 1066 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1067 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1068 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1069 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1070 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1071 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1072 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1073 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1074 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1075 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1076 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1077 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1078 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s80) -Fast allSat, Looking for solution 1078 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1079 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1080 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1081 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1082 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1083 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1084 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1085 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1086 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1087 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1088 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1089 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1090 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s61) -[GOOD] (assert s93) -[GOOD] (assert s81) -Fast allSat, Looking for solution 1090 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1091 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1092 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1093 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 1094 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1095 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1096 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1097 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1098 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1099 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1100 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1101 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1102 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s49) -[GOOD] (define-fun s94 () Bool (= s0 s30)) -[GOOD] (assert s94) -Fast allSat, Looking for solution 1102 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s50) -Fast allSat, Looking for solution 1103 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s51) -Fast allSat, Looking for solution 1104 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s52) -Fast allSat, Looking for solution 1105 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s53) -Fast allSat, Looking for solution 1106 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s54) -Fast allSat, Looking for solution 1107 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s55) -Fast allSat, Looking for solution 1108 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s47) -Fast allSat, Looking for solution 1109 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s46) -Fast allSat, Looking for solution 1110 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s45) -Fast allSat, Looking for solution 1111 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s43) -Fast allSat, Looking for solution 1112 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s57) -Fast allSat, Looking for solution 1113 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s87) -Fast allSat, Looking for solution 1114 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s56) -Fast allSat, Looking for solution 1115 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s64) -[GOOD] (assert s73) -Fast allSat, Looking for solution 1115 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1116 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1117 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1118 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1119 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1120 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1121 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1122 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1123 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1124 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1125 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1126 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 1127 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s64) -[GOOD] (assert s88) -Fast allSat, Looking for solution 1127 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1128 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1129 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1130 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1131 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1132 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1133 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1134 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1135 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1136 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1137 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1138 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1139 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s64) -[GOOD] (assert s59) -Fast allSat, Looking for solution 1139 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1140 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1141 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1142 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1143 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1144 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1145 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1146 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 1147 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1148 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1149 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1150 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1151 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s64) -[GOOD] (assert s85) -Fast allSat, Looking for solution 1151 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1152 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1153 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1154 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1155 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 1156 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1157 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1158 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1159 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1160 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1161 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1162 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1163 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s64) -[GOOD] (assert s84) -Fast allSat, Looking for solution 1163 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1164 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1165 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1166 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1167 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1168 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1169 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1170 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1171 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1172 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 1173 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1174 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1175 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s64) -[GOOD] (assert s83) -Fast allSat, Looking for solution 1175 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1176 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1177 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1178 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1179 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 1180 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1181 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1182 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1183 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1184 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1185 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1186 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1187 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s64) -[GOOD] (assert s82) -Fast allSat, Looking for solution 1187 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1188 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1189 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1190 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1191 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1192 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1193 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1194 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1195 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1196 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1197 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1198 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 1199 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s71) -[GOOD] (assert s74) -Fast allSat, Looking for solution 1199 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 1200 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1201 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1202 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1203 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1204 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1205 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1206 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1207 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1208 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1209 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1210 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1211 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s70) -[GOOD] (assert s75) -Fast allSat, Looking for solution 1211 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1212 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1213 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1214 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1215 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1216 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1217 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1218 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1219 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1220 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1221 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 1222 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1223 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s69) -[GOOD] (assert s76) -Fast allSat, Looking for solution 1223 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1224 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1225 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1226 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1227 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1228 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1229 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1230 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 1231 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1232 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1233 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1234 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1235 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s68) -[GOOD] (assert s77) -Fast allSat, Looking for solution 1235 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1236 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1237 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1238 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1239 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1240 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1241 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1242 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1243 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 1244 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1245 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1246 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1247 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s67) -[GOOD] (assert s78) -Fast allSat, Looking for solution 1247 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1248 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1249 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1250 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1251 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1252 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1253 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1254 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1255 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1256 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 1257 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1258 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1259 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s66) -[GOOD] (assert s79) -Fast allSat, Looking for solution 1259 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1260 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1261 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1262 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1263 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1264 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1265 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 1266 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1267 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1268 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1269 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1270 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1271 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s62) -[GOOD] (assert s94) -[GOOD] (assert s80) -Fast allSat, Looking for solution 1271 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1272 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1273 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1274 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1275 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1276 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1277 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1278 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1279 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1280 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1281 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1282 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 1283 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s50) -[GOOD] (define-fun s95 () Bool (= s0 s28)) -[GOOD] (assert s95) -Fast allSat, Looking for solution 1283 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s51) -Fast allSat, Looking for solution 1284 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s52) -Fast allSat, Looking for solution 1285 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s53) -Fast allSat, Looking for solution 1286 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s54) -Fast allSat, Looking for solution 1287 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s55) -Fast allSat, Looking for solution 1288 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s56) -Fast allSat, Looking for solution 1289 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s48) -Fast allSat, Looking for solution 1290 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s47) -Fast allSat, Looking for solution 1291 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s46) -Fast allSat, Looking for solution 1292 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s45) -Fast allSat, Looking for solution 1293 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s43) -Fast allSat, Looking for solution 1294 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s57) -Fast allSat, Looking for solution 1295 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s87) -Fast allSat, Looking for solution 1296 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s72) -[GOOD] (assert s88) -Fast allSat, Looking for solution 1296 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1297 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1298 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1299 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1300 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1301 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1302 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1303 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1304 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1305 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1306 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1307 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1308 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s59) -Fast allSat, Looking for solution 1308 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1309 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1310 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1311 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1312 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1313 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1314 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1315 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1316 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1317 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1318 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1319 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1320 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s85) -Fast allSat, Looking for solution 1320 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1321 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1322 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1323 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1324 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1325 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1326 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1327 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1328 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1329 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1330 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1331 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1332 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s84) -Fast allSat, Looking for solution 1332 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1333 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1334 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1335 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1336 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1337 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1338 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1339 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1340 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1341 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1342 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1343 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1344 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s83) -Fast allSat, Looking for solution 1344 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1345 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1346 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1347 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1348 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1349 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1350 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1351 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1352 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1353 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1354 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1355 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1356 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s82) -Fast allSat, Looking for solution 1356 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1357 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1358 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1359 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1360 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1361 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1362 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1363 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1364 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1365 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1366 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1367 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1368 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s81) -Fast allSat, Looking for solution 1368 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1369 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1370 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1371 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1372 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1373 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1374 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1375 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1376 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1377 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1378 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1379 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1380 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s73) -Fast allSat, Looking for solution 1380 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1381 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1382 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1383 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1384 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1385 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1386 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1387 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1388 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1389 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1390 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1391 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1392 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s74) -Fast allSat, Looking for solution 1392 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1393 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1394 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1395 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1396 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1397 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1398 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1399 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1400 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1401 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1402 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1403 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1404 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s75) -Fast allSat, Looking for solution 1404 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1405 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1406 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1407 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1408 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1409 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1410 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1411 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1412 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1413 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1414 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1415 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1416 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s76) -Fast allSat, Looking for solution 1416 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1417 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1418 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1419 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1420 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1421 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1422 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1423 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1424 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1425 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1426 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1427 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1428 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s77) -Fast allSat, Looking for solution 1428 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1429 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1430 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1431 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1432 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1433 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1434 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1435 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1436 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1437 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1438 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1439 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1440 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s78) -Fast allSat, Looking for solution 1440 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1441 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1442 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1443 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1444 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1445 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1446 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1447 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1448 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1449 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1450 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1451 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1452 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s63) -[GOOD] (assert s95) -[GOOD] (assert s79) -Fast allSat, Looking for solution 1452 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1453 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1454 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1455 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1456 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1457 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1458 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1459 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1460 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1461 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 1462 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1463 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1464 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s51) -[GOOD] (define-fun s96 () Bool (= s0 s26)) -[GOOD] (assert s96) -Fast allSat, Looking for solution 1464 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s52) -Fast allSat, Looking for solution 1465 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s53) -Fast allSat, Looking for solution 1466 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s54) -Fast allSat, Looking for solution 1467 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s55) -Fast allSat, Looking for solution 1468 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s56) -Fast allSat, Looking for solution 1469 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s49) -Fast allSat, Looking for solution 1470 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s48) -Fast allSat, Looking for solution 1471 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s47) -Fast allSat, Looking for solution 1472 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s46) -Fast allSat, Looking for solution 1473 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s45) -Fast allSat, Looking for solution 1474 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s43) -Fast allSat, Looking for solution 1475 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s57) -Fast allSat, Looking for solution 1476 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s87) -Fast allSat, Looking for solution 1477 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s72) -[GOOD] (assert s88) -Fast allSat, Looking for solution 1477 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1478 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1479 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1480 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1481 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1482 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1483 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1484 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1485 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1486 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1487 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1488 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1489 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s59) -Fast allSat, Looking for solution 1489 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1490 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1491 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1492 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1493 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1494 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1495 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1496 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1497 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1498 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1499 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1500 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1501 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s72) -[GOOD] (assert s85) -Fast allSat, Looking for solution 1501 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 1502 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1503 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1504 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1505 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1506 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1507 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1508 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1509 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1510 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1511 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1512 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1513 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s58) -[GOOD] (assert s84) -Fast allSat, Looking for solution 1513 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1514 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 1515 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1516 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1517 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1518 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1519 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1520 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1521 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1522 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1523 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1524 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1525 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s60) -[GOOD] (assert s83) -Fast allSat, Looking for solution 1525 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1526 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1527 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1528 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 1529 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1530 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1531 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1532 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1533 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1534 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1535 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1536 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1537 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s61) -[GOOD] (assert s82) -Fast allSat, Looking for solution 1537 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1538 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1539 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1540 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1541 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1542 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 1543 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1544 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1545 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1546 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1547 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1548 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1549 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s62) -[GOOD] (assert s81) -Fast allSat, Looking for solution 1549 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1550 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1551 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1552 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1553 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1554 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1555 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1556 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 1557 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1558 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1559 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1560 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1561 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s63) -[GOOD] (assert s80) -Fast allSat, Looking for solution 1561 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1562 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1563 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1564 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1565 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1566 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1567 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1568 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1569 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1570 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 1571 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1572 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1573 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s64) -[GOOD] (assert s73) -Fast allSat, Looking for solution 1573 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1574 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1575 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1576 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1577 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1578 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1579 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1580 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1581 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1582 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1583 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1584 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 1585 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s64) -[GOOD] (assert s74) -Fast allSat, Looking for solution 1585 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1586 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1587 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1588 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 1589 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1590 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1591 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1592 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1593 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1594 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1595 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1596 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1597 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s64) -[GOOD] (assert s75) -Fast allSat, Looking for solution 1597 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1598 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1599 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1600 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1601 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1602 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1603 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1604 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1605 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1606 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1607 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1608 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 1609 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s64) -[GOOD] (assert s76) -Fast allSat, Looking for solution 1609 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1610 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1611 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1612 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 1613 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1614 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1615 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1616 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1617 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1618 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1619 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1620 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1621 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s64) -[GOOD] (assert s77) -Fast allSat, Looking for solution 1621 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1622 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1623 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1624 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1625 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1626 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1627 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1628 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1629 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1630 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1631 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1632 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 1633 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s64) -[GOOD] (assert s96) -[GOOD] (assert s78) -Fast allSat, Looking for solution 1633 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1634 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1635 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1636 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 1637 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1638 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1639 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1640 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1641 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1642 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1643 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1644 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1645 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s52) -[GOOD] (define-fun s97 () Bool (= s0 s24)) -[GOOD] (assert s97) -Fast allSat, Looking for solution 1645 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s53) -Fast allSat, Looking for solution 1646 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s54) -Fast allSat, Looking for solution 1647 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s55) -Fast allSat, Looking for solution 1648 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s56) -Fast allSat, Looking for solution 1649 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s50) -Fast allSat, Looking for solution 1650 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s49) -Fast allSat, Looking for solution 1651 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s48) -Fast allSat, Looking for solution 1652 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s47) -Fast allSat, Looking for solution 1653 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s46) -Fast allSat, Looking for solution 1654 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s45) -Fast allSat, Looking for solution 1655 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s43) -Fast allSat, Looking for solution 1656 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s57) -Fast allSat, Looking for solution 1657 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s87) -Fast allSat, Looking for solution 1658 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s72) -[GOOD] (assert s88) -Fast allSat, Looking for solution 1658 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1659 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1660 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1661 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1662 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1663 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1664 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1665 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1666 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1667 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1668 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1669 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1670 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s59) -Fast allSat, Looking for solution 1670 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1671 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1672 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1673 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1674 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1675 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1676 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1677 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1678 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1679 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1680 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1681 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1682 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s72) -[GOOD] (assert s85) -Fast allSat, Looking for solution 1682 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 1683 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1684 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1685 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1686 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1687 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1688 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1689 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1690 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1691 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1692 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1693 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1694 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s58) -[GOOD] (assert s84) -Fast allSat, Looking for solution 1694 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1695 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 1696 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1697 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1698 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1699 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1700 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1701 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1702 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1703 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1704 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1705 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1706 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s60) -[GOOD] (assert s83) -Fast allSat, Looking for solution 1706 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1707 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1708 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1709 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1710 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1711 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1712 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1713 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1714 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1715 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1716 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1717 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 1718 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s61) -[GOOD] (assert s82) -Fast allSat, Looking for solution 1718 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 1719 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1720 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1721 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1722 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1723 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1724 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1725 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1726 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1727 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1728 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1729 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1730 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s62) -[GOOD] (assert s81) -Fast allSat, Looking for solution 1730 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1731 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1732 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1733 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1734 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1735 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1736 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1737 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1738 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1739 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1740 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1741 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 1742 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s63) -[GOOD] (assert s80) -Fast allSat, Looking for solution 1742 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 1743 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1744 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1745 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1746 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1747 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1748 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1749 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1750 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1751 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1752 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1753 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1754 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s64) -[GOOD] (assert s79) -Fast allSat, Looking for solution 1754 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1755 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1756 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1757 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1758 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1759 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1760 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1761 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1762 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1763 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1764 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1765 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 1766 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s65) -[GOOD] (assert s73) -Fast allSat, Looking for solution 1766 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 1767 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1768 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1769 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1770 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1771 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1772 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1773 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1774 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1775 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1776 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1777 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1778 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s65) -[GOOD] (assert s74) -Fast allSat, Looking for solution 1778 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1779 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1780 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1781 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1782 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1783 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1784 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1785 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1786 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1787 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1788 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1789 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 1790 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s65) -[GOOD] (assert s75) -Fast allSat, Looking for solution 1790 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 1791 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1792 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1793 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1794 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1795 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1796 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1797 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1798 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1799 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1800 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1801 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1802 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s65) -[GOOD] (assert s76) -Fast allSat, Looking for solution 1802 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1803 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1804 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1805 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1806 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1807 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1808 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1809 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1810 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1811 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1812 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1813 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 1814 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s65) -[GOOD] (assert s97) -[GOOD] (assert s77) -Fast allSat, Looking for solution 1814 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 1815 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1816 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1817 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1818 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1819 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1820 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1821 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1822 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1823 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1824 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1825 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1826 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s53) -[GOOD] (define-fun s98 () Bool (= s0 s22)) -[GOOD] (assert s98) -Fast allSat, Looking for solution 1826 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s54) -Fast allSat, Looking for solution 1827 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s55) -Fast allSat, Looking for solution 1828 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s51) -Fast allSat, Looking for solution 1829 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s50) -Fast allSat, Looking for solution 1830 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s49) -Fast allSat, Looking for solution 1831 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s48) -Fast allSat, Looking for solution 1832 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s47) -Fast allSat, Looking for solution 1833 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s46) -Fast allSat, Looking for solution 1834 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s45) -Fast allSat, Looking for solution 1835 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s43) -Fast allSat, Looking for solution 1836 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s57) -Fast allSat, Looking for solution 1837 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s87) -Fast allSat, Looking for solution 1838 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s56) -Fast allSat, Looking for solution 1839 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s68) -[GOOD] (assert s73) -Fast allSat, Looking for solution 1839 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1840 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1841 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1842 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1843 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1844 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1845 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1846 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1847 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1848 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1849 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1850 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 1851 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s68) -[GOOD] (assert s88) -Fast allSat, Looking for solution 1851 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1852 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1853 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1854 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1855 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1856 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1857 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1858 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1859 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1860 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1861 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1862 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1863 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s68) -[GOOD] (assert s59) -Fast allSat, Looking for solution 1863 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1864 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1865 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1866 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 1867 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1868 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1869 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1870 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1871 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1872 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1873 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1874 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1875 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s68) -[GOOD] (assert s85) -Fast allSat, Looking for solution 1875 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1876 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1877 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1878 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1879 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1880 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1881 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1882 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1883 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 1884 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1885 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1886 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1887 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s68) -[GOOD] (assert s84) -Fast allSat, Looking for solution 1887 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1888 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1889 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1890 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1891 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1892 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 1893 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1894 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1895 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1896 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1897 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1898 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1899 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s68) -[GOOD] (assert s83) -Fast allSat, Looking for solution 1899 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1900 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1901 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1902 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1903 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1904 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1905 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1906 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1907 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 1908 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1909 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1910 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1911 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s68) -[GOOD] (assert s82) -Fast allSat, Looking for solution 1911 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1912 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1913 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1914 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1915 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1916 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1917 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1918 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 1919 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1920 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1921 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1922 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1923 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s68) -[GOOD] (assert s81) -Fast allSat, Looking for solution 1923 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1924 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1925 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1926 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1927 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1928 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1929 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1930 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1931 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 1932 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1933 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1934 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1935 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s68) -[GOOD] (assert s80) -Fast allSat, Looking for solution 1935 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1936 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1937 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1938 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1939 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1940 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1941 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1942 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1943 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1944 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 1945 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1946 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1947 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s68) -[GOOD] (assert s79) -Fast allSat, Looking for solution 1947 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1948 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1949 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1950 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1951 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1952 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1953 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1954 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1955 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 1956 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1957 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1958 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1959 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s68) -[GOOD] (assert s78) -Fast allSat, Looking for solution 1959 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1960 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1961 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1962 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1963 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1964 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1965 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1966 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1967 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1968 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1969 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1970 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 1971 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s71) -[GOOD] (assert s74) -Fast allSat, Looking for solution 1971 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 1972 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1973 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1974 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1975 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1976 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1977 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1978 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1979 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1980 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1981 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1982 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1983 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s70) -[GOOD] (assert s75) -Fast allSat, Looking for solution 1983 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1984 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1985 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1986 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1987 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1988 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1989 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1990 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1991 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1992 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1993 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1994 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 1995 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s66) -[GOOD] (assert s98) -[GOOD] (assert s76) -Fast allSat, Looking for solution 1995 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 1996 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1997 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1998 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1999 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2000 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2001 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2002 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2003 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2004 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2005 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2006 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2007 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s54) -[GOOD] (define-fun s99 () Bool (= s0 s20)) -[GOOD] (assert s99) -Fast allSat, Looking for solution 2007 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s55) -Fast allSat, Looking for solution 2008 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s52) -Fast allSat, Looking for solution 2009 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s51) -Fast allSat, Looking for solution 2010 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s50) -Fast allSat, Looking for solution 2011 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s49) -Fast allSat, Looking for solution 2012 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s48) -Fast allSat, Looking for solution 2013 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s47) -Fast allSat, Looking for solution 2014 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s46) -Fast allSat, Looking for solution 2015 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s45) -Fast allSat, Looking for solution 2016 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s43) -Fast allSat, Looking for solution 2017 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s57) -Fast allSat, Looking for solution 2018 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s87) -Fast allSat, Looking for solution 2019 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s56) -Fast allSat, Looking for solution 2020 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s69) -[GOOD] (assert s73) -Fast allSat, Looking for solution 2020 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2021 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2022 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2023 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2024 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2025 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2026 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2027 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2028 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2029 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2030 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2031 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 2032 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s69) -[GOOD] (assert s88) -Fast allSat, Looking for solution 2032 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2033 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2034 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2035 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2036 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2037 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2038 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2039 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2040 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2041 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2042 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2043 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2044 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s69) -[GOOD] (assert s59) -Fast allSat, Looking for solution 2044 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2045 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2046 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2047 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2048 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2049 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2050 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2051 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2052 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2053 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2054 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2055 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 2056 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s69) -[GOOD] (assert s85) -Fast allSat, Looking for solution 2056 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2057 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 2058 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2059 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2060 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2061 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2062 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2063 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2064 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2065 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2066 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2067 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2068 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s69) -[GOOD] (assert s84) -Fast allSat, Looking for solution 2068 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2069 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2070 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2071 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2072 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 2073 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2074 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2075 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2076 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2077 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2078 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2079 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2080 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s69) -[GOOD] (assert s83) -Fast allSat, Looking for solution 2080 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2081 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2082 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2083 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2084 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2085 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2086 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2087 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2088 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2089 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 2090 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2091 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2092 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s69) -[GOOD] (assert s82) -Fast allSat, Looking for solution 2092 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2093 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2094 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2095 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2096 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2097 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2098 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 2099 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2100 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2101 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2102 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2103 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2104 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s69) -[GOOD] (assert s81) -Fast allSat, Looking for solution 2104 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2105 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2106 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2107 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2108 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2109 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2110 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2111 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2112 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2113 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 2114 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2115 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2116 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s69) -[GOOD] (assert s80) -Fast allSat, Looking for solution 2116 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2117 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2118 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2119 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2120 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2121 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2122 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2123 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2124 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 2125 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2126 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2127 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2128 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s69) -[GOOD] (assert s79) -Fast allSat, Looking for solution 2128 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2129 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2130 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2131 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2132 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2133 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2134 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2135 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2136 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2137 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 2138 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2139 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2140 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s69) -[GOOD] (assert s78) -Fast allSat, Looking for solution 2140 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2141 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2142 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2143 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2144 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2145 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2146 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2147 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2148 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2149 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2150 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 2151 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2152 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s69) -[GOOD] (assert s77) -Fast allSat, Looking for solution 2152 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2153 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2154 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2155 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2156 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2157 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2158 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2159 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2160 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2161 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 2162 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2163 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2164 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s71) -[GOOD] (assert s74) -Fast allSat, Looking for solution 2164 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2165 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2166 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2167 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2168 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2169 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2170 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2171 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2172 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2173 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2174 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 2175 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2176 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s67) -[GOOD] (assert s99) -[GOOD] (assert s75) -Fast allSat, Looking for solution 2176 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2177 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2178 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2179 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2180 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2181 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2182 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2183 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2184 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2185 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2186 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2187 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 2188 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s56) -[GOOD] (define-fun s100 () Bool (= s0 s18)) -[GOOD] (assert s100) -Fast allSat, Looking for solution 2188 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s54) -Fast allSat, Looking for solution 2189 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s53) -Fast allSat, Looking for solution 2190 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s52) -Fast allSat, Looking for solution 2191 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s51) -Fast allSat, Looking for solution 2192 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s50) -Fast allSat, Looking for solution 2193 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s49) -Fast allSat, Looking for solution 2194 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s48) -Fast allSat, Looking for solution 2195 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s47) -Fast allSat, Looking for solution 2196 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s46) -Fast allSat, Looking for solution 2197 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s45) -Fast allSat, Looking for solution 2198 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s43) -Fast allSat, Looking for solution 2199 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s57) -Fast allSat, Looking for solution 2200 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s87) -Fast allSat, Looking for solution 2201 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s72) -[GOOD] (assert s88) -Fast allSat, Looking for solution 2201 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2202 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2203 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2204 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2205 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2206 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2207 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2208 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2209 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2210 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2211 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2212 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2213 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s59) -Fast allSat, Looking for solution 2213 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2214 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2215 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2216 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2217 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2218 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2219 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2220 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2221 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2222 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2223 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2224 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2225 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s85) -Fast allSat, Looking for solution 2225 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2226 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2227 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2228 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2229 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2230 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2231 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2232 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2233 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2234 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2235 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2236 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2237 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s84) -Fast allSat, Looking for solution 2237 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2238 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2239 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2240 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2241 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2242 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2243 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2244 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2245 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2246 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2247 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2248 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2249 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s83) -Fast allSat, Looking for solution 2249 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2250 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2251 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2252 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2253 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2254 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2255 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2256 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2257 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2258 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2259 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2260 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2261 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s82) -Fast allSat, Looking for solution 2261 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2262 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2263 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2264 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2265 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2266 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2267 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2268 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2269 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2270 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2271 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2272 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2273 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s81) -Fast allSat, Looking for solution 2273 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2274 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2275 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2276 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2277 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2278 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2279 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2280 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2281 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2282 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2283 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2284 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2285 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s80) -Fast allSat, Looking for solution 2285 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2286 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2287 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2288 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2289 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2290 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2291 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2292 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2293 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2294 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2295 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2296 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2297 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s79) -Fast allSat, Looking for solution 2297 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2298 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2299 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2300 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2301 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2302 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2303 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2304 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2305 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2306 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2307 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2308 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2309 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s78) -Fast allSat, Looking for solution 2309 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2310 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2311 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2312 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2313 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2314 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2315 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2316 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2317 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2318 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2319 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2320 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2321 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s77) -Fast allSat, Looking for solution 2321 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2322 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2323 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2324 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2325 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2326 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2327 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2328 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2329 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2330 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2331 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2332 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2333 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s76) -Fast allSat, Looking for solution 2333 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2334 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2335 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2336 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2337 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2338 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2339 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2340 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2341 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2342 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2343 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2344 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2345 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s75) -Fast allSat, Looking for solution 2345 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2346 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2347 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2348 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2349 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2350 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2351 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2352 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2353 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2354 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2355 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2356 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2357 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s69) -[GOOD] (assert s100) -[GOOD] (assert s73) -Fast allSat, Looking for solution 2357 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2358 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2359 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2360 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2361 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2362 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2363 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2364 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2365 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2366 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2367 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2368 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 2369 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s56) -[GOOD] (define-fun s101 () Bool (= s0 s16)) -[GOOD] (assert s101) -Fast allSat, Looking for solution 2369 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s55) -Fast allSat, Looking for solution 2370 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s53) -Fast allSat, Looking for solution 2371 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s52) -Fast allSat, Looking for solution 2372 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s51) -Fast allSat, Looking for solution 2373 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s50) -Fast allSat, Looking for solution 2374 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s49) -Fast allSat, Looking for solution 2375 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s48) -Fast allSat, Looking for solution 2376 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s47) -Fast allSat, Looking for solution 2377 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s46) -Fast allSat, Looking for solution 2378 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s45) -Fast allSat, Looking for solution 2379 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s43) -Fast allSat, Looking for solution 2380 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s57) -Fast allSat, Looking for solution 2381 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s87) -Fast allSat, Looking for solution 2382 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s72) -[GOOD] (assert s88) -Fast allSat, Looking for solution 2382 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2383 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2384 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2385 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2386 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2387 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2388 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2389 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2390 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2391 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2392 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2393 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2394 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s59) -Fast allSat, Looking for solution 2394 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2395 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2396 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2397 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2398 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2399 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2400 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2401 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2402 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2403 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2404 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2405 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2406 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s85) -Fast allSat, Looking for solution 2406 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2407 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2408 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2409 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2410 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2411 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2412 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2413 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2414 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2415 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2416 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2417 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2418 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s84) -Fast allSat, Looking for solution 2418 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2419 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2420 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2421 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2422 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2423 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2424 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2425 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2426 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2427 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2428 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2429 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2430 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s83) -Fast allSat, Looking for solution 2430 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2431 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2432 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2433 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2434 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2435 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2436 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2437 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2438 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2439 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2440 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2441 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2442 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s82) -Fast allSat, Looking for solution 2442 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2443 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2444 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2445 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2446 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2447 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2448 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2449 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2450 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2451 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2452 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2453 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2454 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s81) -Fast allSat, Looking for solution 2454 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2455 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2456 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2457 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2458 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2459 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2460 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2461 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2462 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2463 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2464 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2465 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2466 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s80) -Fast allSat, Looking for solution 2466 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2467 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2468 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2469 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2470 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2471 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2472 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2473 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2474 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2475 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2476 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2477 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2478 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s79) -Fast allSat, Looking for solution 2478 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2479 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2480 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2481 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2482 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2483 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2484 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2485 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2486 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2487 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2488 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2489 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2490 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s78) -Fast allSat, Looking for solution 2490 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2491 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2492 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2493 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2494 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2495 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2496 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2497 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2498 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2499 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2500 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2501 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2502 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s77) -Fast allSat, Looking for solution 2502 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2503 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2504 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2505 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2506 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2507 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2508 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2509 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2510 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2511 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2512 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2513 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2514 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s76) -Fast allSat, Looking for solution 2514 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2515 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2516 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2517 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2518 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2519 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2520 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2521 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2522 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2523 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2524 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2525 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2526 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s74) -Fast allSat, Looking for solution 2526 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2527 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2528 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2529 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2530 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2531 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2532 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2533 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2534 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2535 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2536 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2537 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2538 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s70) -[GOOD] (assert s101) -[GOOD] (assert s73) -Fast allSat, Looking for solution 2538 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2539 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2540 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2541 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2542 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2543 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2544 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2545 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2546 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2547 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2548 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2549 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s89) -Fast allSat, Looking for solution 2550 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s55) -[GOOD] (define-fun s102 () Bool (= s0 s3)) -[GOOD] (assert s102) -Fast allSat, Looking for solution 2550 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s54) -Fast allSat, Looking for solution 2551 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s53) -Fast allSat, Looking for solution 2552 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s52) -Fast allSat, Looking for solution 2553 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s51) -Fast allSat, Looking for solution 2554 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s50) -Fast allSat, Looking for solution 2555 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s49) -Fast allSat, Looking for solution 2556 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s48) -Fast allSat, Looking for solution 2557 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s47) -Fast allSat, Looking for solution 2558 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s46) -Fast allSat, Looking for solution 2559 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s45) -Fast allSat, Looking for solution 2560 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s43) -Fast allSat, Looking for solution 2561 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s57) -Fast allSat, Looking for solution 2562 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s87) -Fast allSat, Looking for solution 2563 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s72) -[GOOD] (assert s88) -Fast allSat, Looking for solution 2563 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2564 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2565 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2566 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2567 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2568 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2569 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2570 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2571 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2572 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2573 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2574 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2575 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s59) -Fast allSat, Looking for solution 2575 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2576 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2577 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2578 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2579 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2580 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2581 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2582 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2583 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2584 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2585 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2586 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2587 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s85) -Fast allSat, Looking for solution 2587 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2588 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2589 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2590 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2591 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2592 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2593 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2594 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2595 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2596 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2597 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2598 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2599 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s84) -Fast allSat, Looking for solution 2599 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2600 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2601 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2602 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2603 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2604 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2605 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2606 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2607 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2608 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2609 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2610 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2611 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s83) -Fast allSat, Looking for solution 2611 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2612 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2613 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2614 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2615 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2616 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2617 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2618 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2619 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2620 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2621 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2622 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2623 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s82) -Fast allSat, Looking for solution 2623 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2624 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2625 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2626 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2627 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2628 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2629 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2630 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2631 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2632 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2633 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2634 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2635 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s81) -Fast allSat, Looking for solution 2635 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2636 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2637 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2638 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2639 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2640 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2641 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2642 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2643 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2644 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2645 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2646 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2647 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s80) -Fast allSat, Looking for solution 2647 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2648 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2649 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2650 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2651 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2652 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2653 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2654 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2655 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2656 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2657 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2658 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2659 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s79) -Fast allSat, Looking for solution 2659 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2660 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2661 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2662 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2663 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2664 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2665 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2666 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2667 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2668 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2669 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2670 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2671 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s78) -Fast allSat, Looking for solution 2671 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2672 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2673 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2674 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2675 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2676 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2677 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2678 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2679 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2680 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2681 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2682 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2683 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s77) -Fast allSat, Looking for solution 2683 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2684 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2685 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2686 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2687 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2688 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2689 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2690 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2691 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2692 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2693 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2694 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2695 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s76) -Fast allSat, Looking for solution 2695 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2696 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2697 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2698 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2699 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2700 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2701 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2702 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2703 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2704 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2705 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2706 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2707 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s89) -[GOOD] (assert s75) -Fast allSat, Looking for solution 2707 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2708 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2709 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2710 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2711 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2712 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2713 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2714 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2715 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2716 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2717 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2718 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2719 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s69) -[GOOD] (assert s102) -[GOOD] (assert s74) -Fast allSat, Looking for solution 2719 -[SEND] (check-sat) -[RECV] sat -[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) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 42 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 43 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 44 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 45 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 46 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 47 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 49 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 50 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 51 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 52 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 53 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s72) +[GOOD] (define-fun s74 () Bool (= s1 s18)) +[GOOD] (assert s74) +Fast allSat, Looking for solution 53 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 54 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 55 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 56 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 57 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 58 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 59 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 60 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 61 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 62 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 63 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 64 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 65 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s72) +[GOOD] (define-fun s75 () Bool (= s1 s16)) +[GOOD] (assert s75) +Fast allSat, Looking for solution 65 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 66 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 67 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 68 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 69 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 70 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 71 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 72 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 73 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 74 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 75 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 76 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 77 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s72) +[GOOD] (define-fun s76 () Bool (= s1 s20)) +[GOOD] (assert s76) +Fast allSat, Looking for solution 77 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 78 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 79 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 80 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 81 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 82 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 83 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 84 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 85 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 86 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 87 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 88 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 89 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s72) +[GOOD] (define-fun s77 () Bool (= s1 s22)) +[GOOD] (assert s77) +Fast allSat, Looking for solution 89 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 90 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 91 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 92 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 93 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 94 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 95 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 96 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 97 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 98 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 99 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 100 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 101 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s72) +[GOOD] (define-fun s78 () Bool (= s1 s24)) +[GOOD] (assert s78) +Fast allSat, Looking for solution 101 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 102 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 103 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 104 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 105 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 106 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 107 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 108 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 109 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 110 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 111 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 112 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 113 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s72) +[GOOD] (define-fun s79 () Bool (= s1 s26)) +[GOOD] (assert s79) +Fast allSat, Looking for solution 113 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 114 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 115 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 116 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 117 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 118 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 119 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 120 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 121 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 122 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 123 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 124 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 125 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s72) +[GOOD] (define-fun s80 () Bool (= s1 s28)) +[GOOD] (assert s80) +Fast allSat, Looking for solution 125 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 126 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 127 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 128 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 129 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 130 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 131 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 132 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 133 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 134 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 135 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 136 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 137 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s72) +[GOOD] (define-fun s81 () Bool (= s1 s30)) +[GOOD] (assert s81) +Fast allSat, Looking for solution 137 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 138 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 139 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 140 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 141 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 142 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 143 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 144 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 145 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 146 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 147 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 148 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 149 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s72) +[GOOD] (define-fun s82 () Bool (= s1 s32)) +[GOOD] (assert s82) +Fast allSat, Looking for solution 149 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 150 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 151 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 152 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 153 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 154 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 155 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 156 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 157 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 158 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 159 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 160 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 161 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s72) +[GOOD] (define-fun s83 () Bool (= s1 s34)) +[GOOD] (assert s83) +Fast allSat, Looking for solution 161 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 162 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 163 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 164 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 165 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 166 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 167 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 168 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 169 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 170 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 171 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 172 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 173 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s72) +[GOOD] (define-fun s84 () Bool (= s1 s36)) +[GOOD] (assert s84) +Fast allSat, Looking for solution 173 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 174 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 175 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 176 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 177 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 178 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 179 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 180 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 181 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 182 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 183 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 184 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 185 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s72) +[GOOD] (assert s44) +[GOOD] (define-fun s85 () Bool (= s1 s38)) +[GOOD] (assert s85) +Fast allSat, Looking for solution 185 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 186 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 187 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 188 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 189 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 190 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 191 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 192 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 193 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 194 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 195 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 196 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 197 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s43) +[GOOD] (define-fun s86 () Bool (= s0 s40)) +[GOOD] (assert s86) +Fast allSat, Looking for solution 197 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s45) +Fast allSat, Looking for solution 198 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s46) +Fast allSat, Looking for solution 199 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s47) +Fast allSat, Looking for solution 200 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s48) +Fast allSat, Looking for solution 201 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s49) +Fast allSat, Looking for solution 202 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s50) +Fast allSat, Looking for solution 203 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s51) +Fast allSat, Looking for solution 204 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s52) +Fast allSat, Looking for solution 205 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s53) +Fast allSat, Looking for solution 206 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s54) +Fast allSat, Looking for solution 207 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s55) +Fast allSat, Looking for solution 208 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 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 209 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s56) +Fast allSat, Looking for solution 210 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s70) +[GOOD] (assert s73) +Fast allSat, Looking for solution 210 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 211 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 212 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 213 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 214 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 215 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 216 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 217 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 218 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 219 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 220 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 221 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (define-fun s88 () Bool (distinct s2 s5)) +[GOOD] (assert s88) +Fast allSat, Looking for solution 222 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s58) +[GOOD] (define-fun s89 () Bool (= s1 s5)) +[GOOD] (assert s89) +Fast allSat, Looking for solution 222 +[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 223 +[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 224 +[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 225 +[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 226 +[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 227 +[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 228 +[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 229 +[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 230 +[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 231 +[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 232 +[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 233 +[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 234 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s71) +[GOOD] (assert s74) +Fast allSat, Looking for solution 234 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 235 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 236 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 237 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 238 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 240 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 241 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 242 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 243 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 244 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 245 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 246 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s70) +[GOOD] (assert s75) +Fast allSat, Looking for solution 246 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 247 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 249 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 250 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 251 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 252 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 253 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 254 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 255 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 256 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 257 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 258 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s69) +[GOOD] (assert s76) +Fast allSat, Looking for solution 258 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 259 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 260 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 261 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 262 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 263 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 264 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 265 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 266 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 267 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 268 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 269 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 270 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s68) +[GOOD] (assert s77) +Fast allSat, Looking for solution 270 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 271 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 272 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 273 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 274 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 275 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 276 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 277 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 278 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 279 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 280 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 281 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 282 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s67) +[GOOD] (assert s78) +Fast allSat, Looking for solution 282 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 283 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 284 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 285 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 286 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 287 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 288 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 289 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 290 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 291 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 292 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 293 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 294 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s66) +[GOOD] (assert s79) +Fast allSat, Looking for solution 294 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 295 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 296 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 297 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 298 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 299 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 300 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 301 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 302 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 303 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 304 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 305 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 306 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s65) +[GOOD] (assert s80) +Fast allSat, Looking for solution 306 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 307 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 308 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 309 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 310 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 311 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 312 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 8)) +[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 8)) +[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 8)) +[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 8)) +[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 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 318 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s64) +[GOOD] (assert s81) +Fast allSat, Looking for solution 318 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 319 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 321 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 9)) +[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 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 324 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 325 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 326 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 327 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 328 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 329 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 330 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s63) +[GOOD] (assert s82) +Fast allSat, Looking for solution 330 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 331 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 332 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 333 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 334 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 335 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 336 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 337 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 338 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 339 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 340 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 341 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 342 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s62) +[GOOD] (assert s83) +Fast allSat, Looking for solution 342 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 343 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 344 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 345 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 346 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 347 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 348 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 349 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 350 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 351 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 352 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 353 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 354 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s61) +[GOOD] (assert s84) +Fast allSat, Looking for solution 354 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 355 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 356 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 357 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 358 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 359 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 360 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 361 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 362 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 363 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 364 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 365 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 366 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s88) +[GOOD] (assert s86) +[GOOD] (assert s85) +Fast allSat, Looking for solution 366 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 367 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 368 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 369 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 370 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 371 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 372 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 373 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 374 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 375 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 376 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 377 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 378 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s45) +[GOOD] (define-fun s90 () Bool (= s0 s38)) +[GOOD] (assert s90) +Fast allSat, Looking for solution 378 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s46) +Fast allSat, Looking for solution 379 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s47) +Fast allSat, Looking for solution 380 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s48) +Fast allSat, Looking for solution 381 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s49) +Fast allSat, Looking for solution 382 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s50) +Fast allSat, Looking for solution 383 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s51) +Fast allSat, Looking for solution 384 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s52) +Fast allSat, Looking for solution 385 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s53) +Fast allSat, Looking for solution 386 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s54) +Fast allSat, Looking for solution 387 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s55) +Fast allSat, Looking for solution 388 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s57) +Fast allSat, Looking for solution 389 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s87) +Fast allSat, Looking for solution 390 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s56) +Fast allSat, Looking for solution 391 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s70) +[GOOD] (assert s73) +Fast allSat, Looking for solution 391 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 392 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 393 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 394 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 395 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 396 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 397 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 398 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 399 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 400 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 401 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 402 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 403 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s60) +[GOOD] (assert s89) +Fast allSat, Looking for solution 403 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 404 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 15)) +[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 15)) +[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 15)) +[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 15)) +[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 15)) +[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 15)) +[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 15)) +[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 15)) +[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 15)) +[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 15)) +[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 s60) +[GOOD] (assert s59) +Fast allSat, Looking for solution 415 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 416 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 417 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 418 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 419 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 420 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 421 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 422 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 423 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 424 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 425 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 426 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 427 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s71) +[GOOD] (assert s74) +Fast allSat, Looking for solution 427 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 428 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 429 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 430 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 431 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 432 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 433 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 434 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 435 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 436 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 437 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 438 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 439 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s70) +[GOOD] (assert s75) +Fast allSat, Looking for solution 439 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 440 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 441 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 442 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 443 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 444 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 445 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 446 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 447 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 448 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 449 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 451 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s69) +[GOOD] (assert s76) +Fast allSat, Looking for solution 451 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 452 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 454 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 455 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 456 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 457 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 458 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 459 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 460 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 461 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 4)) +[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 s68) +[GOOD] (assert s77) +Fast allSat, Looking for solution 463 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 464 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 465 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 466 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 467 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 468 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 469 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 470 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 471 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 472 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 473 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 475 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s67) +[GOOD] (assert s78) +Fast allSat, Looking for solution 475 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 476 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 478 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 479 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 480 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 481 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 482 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 483 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 6)) +[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 6)) +[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 6)) +[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 s66) +[GOOD] (assert s79) +Fast allSat, Looking for solution 487 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 488 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 489 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 491 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 492 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 493 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 494 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 495 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 496 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 497 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 499 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s65) +[GOOD] (assert s80) +Fast allSat, Looking for solution 499 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 500 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 501 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 502 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 503 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 504 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 505 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 506 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 507 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 8)) +[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 8)) +[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 8)) +[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 s64) +[GOOD] (assert s81) +Fast allSat, Looking for solution 511 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 512 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[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 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 514 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 515 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 516 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 517 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 518 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 519 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 520 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 521 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 523 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s63) +[GOOD] (assert s82) +Fast allSat, Looking for solution 523 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 524 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 525 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 526 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 527 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 528 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 529 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 530 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 531 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 532 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 533 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 10)) +[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 s62) +[GOOD] (assert s83) +Fast allSat, Looking for solution 535 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 537 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 538 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 539 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 540 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 541 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 542 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 543 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 544 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 545 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 547 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s72) +[GOOD] (assert s90) +[GOOD] (assert s84) +Fast allSat, Looking for solution 547 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 548 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 549 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 550 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 551 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 552 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 553 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 554 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 555 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 556 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 557 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 558 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 559 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s46) +[GOOD] (define-fun s91 () Bool (= s0 s36)) +[GOOD] (assert s91) +Fast allSat, Looking for solution 559 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s47) +Fast allSat, Looking for solution 560 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s48) +Fast allSat, Looking for solution 561 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s49) +Fast allSat, Looking for solution 562 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s50) +Fast allSat, Looking for solution 563 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s51) +Fast allSat, Looking for solution 564 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s52) +Fast allSat, Looking for solution 565 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s53) +Fast allSat, Looking for solution 566 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s54) +Fast allSat, Looking for solution 567 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s55) +Fast allSat, Looking for solution 568 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s43) +Fast allSat, Looking for solution 569 +[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 s57) +Fast allSat, Looking for solution 570 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s87) +Fast allSat, Looking for solution 571 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s56) +Fast allSat, Looking for solution 572 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s70) +[GOOD] (assert s73) +Fast allSat, Looking for solution 572 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 573 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 574 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 575 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 576 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 577 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 578 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 579 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 580 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 581 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 582 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 583 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 584 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s61) +[GOOD] (assert s89) +Fast allSat, Looking for solution 584 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 585 +[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 586 +[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 587 +[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 588 +[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 589 +[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 590 +[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 591 +[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 592 +[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 593 +[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 594 +[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 595 +[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 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 s61) +[GOOD] (assert s59) +Fast allSat, Looking for solution 596 +[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 597 +[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 598 +[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 599 +[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 600 +[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 601 +[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 602 +[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 603 +[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 604 +[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 605 +[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 606 +[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 607 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 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 s61) +[GOOD] (assert s85) +Fast allSat, Looking for solution 608 +[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 609 +[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 610 +[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 611 +[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 612 +[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 613 +[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 614 +[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 615 +[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 616 +[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 617 +[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 618 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 619 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 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 s71) +[GOOD] (assert s74) +Fast allSat, Looking for solution 620 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 621 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 622 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 623 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 624 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 625 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 626 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 627 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 628 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 629 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 630 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 631 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +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 s70) +[GOOD] (assert s75) +Fast allSat, Looking for solution 632 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 633 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 634 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 635 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 636 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 637 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 638 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 639 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 640 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 641 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 642 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 643 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 644 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s69) +[GOOD] (assert s76) +Fast allSat, Looking for solution 644 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 645 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 646 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 648 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 649 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 650 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 651 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 652 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 653 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[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 4)) +[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 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +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 s68) +[GOOD] (assert s77) +Fast allSat, Looking for solution 656 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 657 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 5)) +[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 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 660 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 661 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 662 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 663 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 664 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 665 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 666 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 667 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 668 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s67) +[GOOD] (assert s78) +Fast allSat, Looking for solution 668 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +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 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +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 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 672 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +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 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 674 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 675 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 676 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 677 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 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 s88) +Fast allSat, Looking for solution 680 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s66) +[GOOD] (assert s79) +Fast allSat, Looking for solution 680 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 681 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 682 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 683 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 684 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 685 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 686 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 687 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 688 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 689 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 690 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 691 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +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 s65) +[GOOD] (assert s80) +Fast allSat, Looking for solution 692 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 693 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 694 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 695 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 696 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 697 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 698 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 699 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 700 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 701 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 702 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 703 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +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 s64) +[GOOD] (assert s81) +Fast allSat, Looking for solution 704 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 705 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 706 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 707 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 708 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 709 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 710 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 712 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 713 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 714 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 715 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +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 s63) +[GOOD] (assert s82) +Fast allSat, Looking for solution 716 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 717 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 718 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 719 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 720 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 721 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 722 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 723 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 724 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 725 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 726 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 727 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 728 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s58) +[GOOD] (assert s91) +[GOOD] (assert s83) +Fast allSat, Looking for solution 728 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 729 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 730 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 731 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 732 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 733 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 734 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 736 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 737 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 738 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 739 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 740 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s47) +[GOOD] (define-fun s92 () Bool (= s0 s34)) +[GOOD] (assert s92) +Fast allSat, Looking for solution 740 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s48) +Fast allSat, Looking for solution 741 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s49) +Fast allSat, Looking for solution 742 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s50) +Fast allSat, Looking for solution 743 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s51) +Fast allSat, Looking for solution 744 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s52) +Fast allSat, Looking for solution 745 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s53) +Fast allSat, Looking for solution 746 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s54) +Fast allSat, Looking for solution 747 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s55) +Fast allSat, Looking for solution 748 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s56) +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 15)) +[GOOD] (push 1) +[GOOD] (assert s45) +Fast allSat, Looking for solution 750 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s43) +Fast allSat, Looking for solution 751 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s57) +Fast allSat, Looking for solution 752 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s87) +Fast allSat, Looking for solution 753 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s72) +[GOOD] (assert s89) +Fast allSat, Looking for solution 753 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 754 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 755 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 756 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 757 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 758 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 759 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 760 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 761 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 762 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 763 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 764 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 765 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s88) +[GOOD] (assert s59) +Fast allSat, Looking for solution 765 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 766 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 767 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 768 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 769 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 770 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 771 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 772 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 773 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 774 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 775 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 776 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 777 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s88) +[GOOD] (assert s85) +Fast allSat, Looking for solution 777 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 778 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 779 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 780 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 781 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 782 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 783 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 784 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 785 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 786 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 787 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 788 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 789 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s88) +[GOOD] (assert s84) +Fast allSat, Looking for solution 789 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +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 s88) +[GOOD] (assert s73) +Fast allSat, Looking for solution 801 +[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 802 +[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 803 +[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 804 +[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 805 +[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 806 +[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 807 +[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 808 +[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 809 +[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 810 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 811 +[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 812 +[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 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 s88) +[GOOD] (assert s74) +Fast allSat, Looking for solution 813 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 814 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 815 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 816 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 817 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 818 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 819 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 820 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 821 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 822 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 823 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 824 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 s88) +[GOOD] (assert s75) +Fast allSat, Looking for solution 825 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 826 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 827 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 828 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 829 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 830 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 831 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 832 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[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 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 834 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 835 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 836 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 837 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s88) +[GOOD] (assert s76) +Fast allSat, Looking for solution 837 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 838 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 839 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 840 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 841 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 4)) +[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 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 844 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 845 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 846 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 4)) +[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 4)) +[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 s88) +[GOOD] (assert s77) +Fast allSat, Looking for solution 849 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 850 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 851 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 852 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 853 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 854 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 5)) +[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 5)) +[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 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 858 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 859 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 860 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 861 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s88) +[GOOD] (assert s78) +Fast allSat, Looking for solution 861 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 862 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 863 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 864 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 865 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 6)) +[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 6)) +[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 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 869 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 6)) +[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 6)) +[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 6)) +[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 s88) +[GOOD] (assert s79) +Fast allSat, Looking for solution 873 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 874 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 875 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 876 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 877 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 878 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 879 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 7)) +[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 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 882 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 883 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 884 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 885 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s88) +[GOOD] (assert s80) +Fast allSat, Looking for solution 885 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 886 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 887 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 888 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 889 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 890 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 891 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 892 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 893 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 894 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 895 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 8)) +[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 s88) +[GOOD] (assert s81) +Fast allSat, Looking for solution 897 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 898 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 899 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 900 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 902 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 903 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 904 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 905 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 906 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 907 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 908 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 909 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s60) +[GOOD] (assert s92) +[GOOD] (assert s82) +Fast allSat, Looking for solution 909 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 910 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 911 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[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 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 913 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 914 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 915 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 916 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 917 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 918 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 919 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 920 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 921 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s48) +[GOOD] (define-fun s93 () Bool (= s0 s32)) +[GOOD] (assert s93) +Fast allSat, Looking for solution 921 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s49) +Fast allSat, Looking for solution 922 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s50) +Fast allSat, Looking for solution 923 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s51) +Fast allSat, Looking for solution 924 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s52) +Fast allSat, Looking for solution 925 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s53) +Fast allSat, Looking for solution 926 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s54) +Fast allSat, Looking for solution 927 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s55) +Fast allSat, Looking for solution 928 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s46) +Fast allSat, Looking for solution 929 +[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 s45) +Fast allSat, Looking for solution 930 +[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 s43) +Fast allSat, Looking for solution 931 +[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 s57) +Fast allSat, Looking for solution 932 +[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 s87) +Fast allSat, Looking for solution 933 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s56) +Fast allSat, Looking for solution 934 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s70) +[GOOD] (assert s73) +Fast allSat, Looking for solution 934 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 935 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 936 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 937 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 938 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 939 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 940 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 941 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 942 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 943 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 944 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 945 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 946 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s63) +[GOOD] (assert s89) +Fast allSat, Looking for solution 946 +[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 947 +[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 948 +[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 949 +[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 s72) +Fast allSat, Looking for solution 950 +[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 951 +[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 952 +[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 953 +[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 954 +[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 955 +[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 956 +[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 957 +[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 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 s63) +[GOOD] (assert s59) +Fast allSat, Looking for solution 958 +[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 959 +[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 960 +[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 961 +[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 962 +[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 963 +[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 964 +[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 965 +[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 966 +[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 967 +[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 968 +[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 969 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 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 s63) +[GOOD] (assert s85) +Fast allSat, Looking for solution 970 +[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 971 +[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 972 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 973 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 974 +[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 975 +[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 976 +[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 977 +[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 978 +[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 979 +[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 980 +[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 981 +[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 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 s63) +[GOOD] (assert s84) +Fast allSat, Looking for solution 982 +[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 983 +[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 984 +[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 985 +[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 986 +[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 987 +[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 988 +[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 989 +[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 990 +[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 991 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 992 +[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 993 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 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 s63) +[GOOD] (assert s83) +Fast allSat, Looking for solution 994 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 995 +[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 996 +[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 997 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 998 +[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 999 +[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 1000 +[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 1001 +[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 1002 +[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 1003 +[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 1004 +[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 1005 +[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 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 s71) +[GOOD] (assert s74) +Fast allSat, Looking for solution 1006 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1007 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1008 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 1010 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1011 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 1012 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 1013 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 2)) +[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 2)) +[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 2)) +[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 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1018 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s70) +[GOOD] (assert s75) +Fast allSat, Looking for solution 1018 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1019 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 3)) +[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 3)) +[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 3)) +[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 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 1024 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 1025 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1026 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 1027 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1028 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1029 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1030 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s69) +[GOOD] (assert s76) +Fast allSat, Looking for solution 1030 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1031 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1032 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1033 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 1034 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1035 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 1036 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 1037 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[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 4)) +[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 4)) +[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 4)) +[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 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1042 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s68) +[GOOD] (assert s77) +Fast allSat, Looking for solution 1042 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +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 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +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 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +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 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +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 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +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 s67) +[GOOD] (assert s78) +Fast allSat, Looking for solution 1054 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1055 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1057 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1058 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1059 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 1060 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 1061 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[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 6)) +[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 6)) +[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 6)) +[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 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1066 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s66) +[GOOD] (assert s79) +Fast allSat, Looking for solution 1066 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1067 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 7)) +[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 7)) +[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 7)) +[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 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 1072 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 1073 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1074 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1075 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1076 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1077 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1078 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s65) +[GOOD] (assert s80) +Fast allSat, Looking for solution 1078 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1080 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1081 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1082 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1083 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 1084 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 1085 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[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 8)) +[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 8)) +[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 8)) +[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 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1090 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s61) +[GOOD] (assert s93) +[GOOD] (assert s81) +Fast allSat, Looking for solution 1090 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1091 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1092 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1093 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1094 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 1095 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1096 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 1097 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1098 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1099 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1100 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1101 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1102 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s49) +[GOOD] (define-fun s94 () Bool (= s0 s30)) +[GOOD] (assert s94) +Fast allSat, Looking for solution 1102 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s50) +Fast allSat, Looking for solution 1103 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s51) +Fast allSat, Looking for solution 1104 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s52) +Fast allSat, Looking for solution 1105 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s53) +Fast allSat, Looking for solution 1106 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s54) +Fast allSat, Looking for solution 1107 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s55) +Fast allSat, Looking for solution 1108 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s47) +Fast allSat, Looking for solution 1109 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s46) +Fast allSat, Looking for solution 1110 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s45) +Fast allSat, Looking for solution 1111 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s43) +Fast allSat, Looking for solution 1112 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s57) +Fast allSat, Looking for solution 1113 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s87) +Fast allSat, Looking for solution 1114 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s56) +Fast allSat, Looking for solution 1115 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s70) +[GOOD] (assert s73) +Fast allSat, Looking for solution 1115 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1116 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1117 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1118 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 1119 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1120 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 1121 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1122 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1123 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1124 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1125 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1126 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1127 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s64) +[GOOD] (assert s89) +Fast allSat, Looking for solution 1127 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1128 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1129 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1130 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1131 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1132 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1133 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 1134 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1135 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1136 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1137 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1138 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1139 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s64) +[GOOD] (assert s59) +Fast allSat, Looking for solution 1139 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1140 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1141 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1142 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1143 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1144 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 1145 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1146 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 14)) +[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 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1149 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1150 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1151 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s64) +[GOOD] (assert s85) +Fast allSat, Looking for solution 1151 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1152 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1153 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1154 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1155 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 1156 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1157 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1158 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1159 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1160 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1161 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1162 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1163 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s64) +[GOOD] (assert s84) +Fast allSat, Looking for solution 1163 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1164 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1165 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1166 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1167 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1168 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1169 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 1170 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1171 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1172 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1173 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1174 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1175 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s64) +[GOOD] (assert s83) +Fast allSat, Looking for solution 1175 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1176 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1177 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1178 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1179 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1180 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 1181 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1182 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1183 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1184 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1185 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1186 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1187 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s64) +[GOOD] (assert s82) +Fast allSat, Looking for solution 1187 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1188 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 1189 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1190 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1191 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1192 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1193 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1194 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1195 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1196 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1197 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1198 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1199 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s71) +[GOOD] (assert s74) +Fast allSat, Looking for solution 1199 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1200 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1201 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1202 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1203 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1204 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1205 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 1206 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1207 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 1208 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1209 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1210 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1211 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s70) +[GOOD] (assert s75) +Fast allSat, Looking for solution 1211 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 1212 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1213 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 1214 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1215 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1216 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1217 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1218 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1219 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1220 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1221 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1222 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1223 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s69) +[GOOD] (assert s76) +Fast allSat, Looking for solution 1223 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1224 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1225 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1226 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 1227 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1228 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 1229 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1230 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1231 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1232 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1233 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1234 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1235 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s68) +[GOOD] (assert s77) +Fast allSat, Looking for solution 1235 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1236 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1237 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1238 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1239 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1240 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1241 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 1242 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1243 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 1244 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1245 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1246 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1247 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s67) +[GOOD] (assert s78) +Fast allSat, Looking for solution 1247 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1248 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1249 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1250 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1251 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1252 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 1253 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1254 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1255 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1256 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1257 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1258 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1259 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s66) +[GOOD] (assert s79) +Fast allSat, Looking for solution 1259 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1260 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1261 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1262 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1263 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1264 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1265 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1266 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1267 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1268 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1269 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1270 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 1271 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s62) +[GOOD] (assert s94) +[GOOD] (assert s80) +Fast allSat, Looking for solution 1271 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1272 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 1273 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1274 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1275 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1276 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1277 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1278 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1279 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1280 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1281 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1282 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1283 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s50) +[GOOD] (define-fun s95 () Bool (= s0 s28)) +[GOOD] (assert s95) +Fast allSat, Looking for solution 1283 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s47) +Fast allSat, Looking for solution 1284 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert 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 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s45) +Fast allSat, Looking for solution 1286 +[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 s51) +Fast allSat, Looking for solution 1287 +[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 s43) +Fast allSat, Looking for solution 1288 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s52) +Fast allSat, Looking for solution 1289 +[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 s57) +Fast allSat, Looking for solution 1290 +[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 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 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s87) +Fast allSat, Looking for solution 1292 +[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 s54) +Fast allSat, Looking for solution 1293 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s55) +Fast allSat, Looking for solution 1294 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s48) +Fast allSat, Looking for solution 1295 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s56) +Fast allSat, Looking for solution 1296 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s63) +[GOOD] (assert s73) +Fast allSat, Looking for solution 1296 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1297 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1298 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1299 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1300 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1301 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1302 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1303 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 1304 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1305 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1306 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1307 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1308 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s65) +[GOOD] (assert s81) +Fast allSat, Looking for solution 1308 +[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 1309 +[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 1310 +[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 1311 +[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 1312 +[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 1313 +[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 1314 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1315 +[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 1316 +[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 1317 +[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 1318 +[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 1319 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 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 s71) +[GOOD] (assert s74) +Fast allSat, Looking for solution 1320 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1321 +[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 1322 +[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 1323 +[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 1324 +[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 1325 +[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 1326 +[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 1327 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1328 +[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 1329 +[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 1330 +[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 1331 +[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 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 s70) +[GOOD] (assert s75) +Fast allSat, Looking for solution 1332 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1333 +[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 1334 +[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 1335 +[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 1336 +[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 1337 +[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 1338 +[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 1339 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1340 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1341 +[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 1342 +[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 1343 +[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 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 s72) +[GOOD] (assert s89) +Fast allSat, Looking for solution 1344 +[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 1345 +[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 1346 +[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 1347 +[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 1348 +[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 1349 +[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 1350 +[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 1351 +[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 1352 +[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 1353 +[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 1354 +[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 1355 +[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 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 s69) +[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 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1357 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1358 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 1359 +[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 1360 +[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 1361 +[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 1362 +[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 1363 +[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 1364 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1365 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1366 +[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 1367 +[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 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 s58) +[GOOD] (assert s59) +Fast allSat, Looking for solution 1368 +[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 1369 +[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 1370 +[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 1371 +[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 1372 +[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 1373 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1374 +[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 1375 +[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 1376 +[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 1377 +[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 1378 +[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 1379 +[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 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 s68) +[GOOD] (assert s77) +Fast allSat, Looking for solution 1380 +[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 1381 +[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 1382 +[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 1383 +[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 1384 +[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 1385 +[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 1386 +[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 1387 +[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 1388 +[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 1389 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1390 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1391 +[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 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 s60) +[GOOD] (assert s85) +Fast allSat, Looking for solution 1392 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[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 13)) +[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 13)) +[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 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1396 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1397 +[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 1398 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1399 +[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 1400 +[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 1401 +[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 1402 +[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 1403 +[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 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 s67) +[GOOD] (assert s78) +Fast allSat, Looking for solution 1404 +[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 1405 +[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 1406 +[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 1407 +[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 1408 +[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 1409 +[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 1410 +[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 1411 +[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 1412 +[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 1413 +[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 1414 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1415 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1416 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s63) +[GOOD] (assert s84) +Fast allSat, Looking for solution 1416 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1417 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1418 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1419 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1420 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 1421 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1422 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1423 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1424 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1425 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1426 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1427 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1428 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s63) +[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 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1429 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1430 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1431 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 1432 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1433 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1434 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1435 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1436 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1437 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1438 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1439 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1440 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s63) +[GOOD] (assert s82) +Fast allSat, Looking for solution 1440 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1441 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1442 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1443 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1444 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1445 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 1446 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1447 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1448 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1449 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1450 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1451 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1452 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s63) +[GOOD] (assert s95) +[GOOD] (assert s79) +Fast allSat, Looking for solution 1452 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 1453 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1454 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1455 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1456 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1457 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1458 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1459 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1460 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1461 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1462 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1463 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1464 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s51) +[GOOD] (define-fun s96 () Bool (= s0 s26)) +[GOOD] (assert s96) +Fast allSat, Looking for solution 1464 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s48) +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 s47) +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 s46) +Fast allSat, Looking for solution 1467 +[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 s52) +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 11)) +[GOOD] (push 1) +[GOOD] (assert s45) +Fast allSat, Looking for solution 1469 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s53) +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 12)) +[GOOD] (push 1) +[GOOD] (assert s43) +Fast allSat, Looking for solution 1471 +[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 s54) +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 13)) +[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 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s55) +Fast allSat, Looking for solution 1474 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[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 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s49) +Fast allSat, Looking for solution 1476 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s56) +Fast allSat, Looking for solution 1477 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s64) +[GOOD] (assert s73) +Fast allSat, Looking for solution 1477 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 1478 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1479 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1480 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[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 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1482 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1483 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1484 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 1485 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1486 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1487 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1488 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +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 s66) +[GOOD] (assert s80) +Fast allSat, Looking for solution 1489 +[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 1490 +[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 1491 +[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 1492 +[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 1493 +[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 1494 +[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 s63) +Fast allSat, Looking for solution 1495 +[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 1496 +[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 1497 +[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 1498 +[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 1499 +[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 1500 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1501 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s72) +[GOOD] (assert s89) +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 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +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 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1503 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1504 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1505 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 1506 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 1507 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 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 s71) +[GOOD] (assert s74) +Fast allSat, Looking for solution 1513 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 1514 +[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 1515 +[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 1516 +[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 1517 +[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 1518 +[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 1519 +[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 1520 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1521 +[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 1522 +[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 1523 +[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 1524 +[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 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 s58) +[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 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +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 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 1531 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 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 s70) +[GOOD] (assert s75) +Fast allSat, Looking for solution 1537 +[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 1538 +[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 1539 +[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 1540 +[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 1541 +[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 s64) +Fast allSat, Looking for solution 1542 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 1543 +[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 1544 +[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 1545 +[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 1546 +[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 1547 +[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 1548 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 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 s60) +[GOOD] (assert s85) +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 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +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 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +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 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1552 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1553 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +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 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +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 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 1556 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 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 s69) +[GOOD] (assert s76) +Fast allSat, Looking for solution 1561 +[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 1562 +[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 1563 +[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 1564 +[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 1565 +[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 s64) +Fast allSat, Looking for solution 1566 +[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 1567 +[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 1568 +[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 1569 +[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 1570 +[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 1571 +[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 1572 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 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 s61) +[GOOD] (assert s84) +Fast allSat, Looking for solution 1573 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +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 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +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 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +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 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +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 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +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 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +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 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +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 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +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 s68) +[GOOD] (assert s77) +Fast allSat, Looking for solution 1585 +[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 1586 +[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 1587 +[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 1588 +[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 1589 +[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 s64) +Fast allSat, Looking for solution 1590 +[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 1591 +[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 1592 +[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 1593 +[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 1594 +[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 1595 +[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 1596 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 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 s83) +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 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +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 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +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 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +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 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +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 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1602 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 1603 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +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 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +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 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +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 s82) +Fast allSat, Looking for solution 1609 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 1610 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1611 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1612 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1613 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1614 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +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 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 1616 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +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 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1618 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1619 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1620 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1621 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s64) +[GOOD] (assert s81) +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 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +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 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +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 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +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 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +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 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +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 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +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 s78) +Fast allSat, Looking for solution 1633 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1634 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1635 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1636 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1637 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1638 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[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 6)) +[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 6)) +[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 6)) +[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 6)) +[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 6)) +[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 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1645 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s52) +[GOOD] (define-fun s97 () Bool (= s0 s24)) +[GOOD] (assert s97) +Fast allSat, Looking for solution 1645 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s53) +Fast allSat, Looking for solution 1646 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s54) +Fast allSat, Looking for solution 1647 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s55) +Fast allSat, Looking for solution 1648 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s56) +Fast allSat, Looking for solution 1649 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 s49) +Fast allSat, Looking for solution 1651 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s48) +Fast allSat, Looking for solution 1652 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s47) +Fast allSat, Looking for solution 1653 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s46) +Fast allSat, Looking for solution 1654 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s45) +Fast allSat, Looking for solution 1655 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s43) +Fast allSat, Looking for solution 1656 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s57) +Fast allSat, Looking for solution 1657 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s87) +Fast allSat, Looking for solution 1658 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s72) +[GOOD] (assert s89) +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 s88) +[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 s88) +[GOOD] (assert s85) +Fast allSat, Looking for solution 1682 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 s88) +[GOOD] (assert s84) +Fast allSat, Looking for solution 1694 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 s88) +[GOOD] (assert s83) +Fast allSat, Looking for solution 1706 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 s88) +[GOOD] (assert s82) +Fast allSat, Looking for solution 1718 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 s88) +[GOOD] (assert s81) +Fast allSat, Looking for solution 1730 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 s88) +[GOOD] (assert s80) +Fast allSat, Looking for solution 1742 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 s88) +[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 s88) +[GOOD] (assert s73) +Fast allSat, Looking for solution 1766 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1767 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1768 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1769 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1770 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 1)) +[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 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 1773 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 1)) +[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 1)) +[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 1)) +[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 1)) +[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 s88) +[GOOD] (assert s74) +Fast allSat, Looking for solution 1778 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 2)) +[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 2)) +[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 2)) +[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 2)) +[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 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 1784 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 2)) +[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 2)) +[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 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1788 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1789 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 s88) +[GOOD] (assert s75) +Fast allSat, Looking for solution 1790 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 s88) +[GOOD] (assert s76) +Fast allSat, Looking for solution 1802 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 4)) +[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 4)) +[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 4)) +[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 4)) +[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 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 1808 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 4)) +[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 4)) +[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 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1812 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1813 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 s77) +Fast allSat, Looking for solution 1814 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1815 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1817 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1818 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 5)) +[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 5)) +[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 5)) +[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 5)) +[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 5)) +[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 5)) +[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 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1826 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s53) +[GOOD] (define-fun s98 () Bool (= s0 s22)) +[GOOD] (assert s98) +Fast allSat, Looking for solution 1826 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s54) +Fast allSat, Looking for solution 1827 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s55) +Fast allSat, Looking for solution 1828 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s56) +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 s51) +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 s49) +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 s48) +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 s47) +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 s46) +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 s45) +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 s43) +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 s89) +Fast allSat, Looking for solution 1839 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 s88) +[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 s88) +[GOOD] (assert s85) +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 s88) +[GOOD] (assert s84) +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 s88) +[GOOD] (assert s83) +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 s88) +[GOOD] (assert s82) +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 s88) +[GOOD] (assert s81) +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 s88) +[GOOD] (assert s80) +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 s88) +[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 s88) +[GOOD] (assert s78) +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 s88) +[GOOD] (assert s73) +Fast allSat, Looking for solution 1959 +[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 1960 +[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 1961 +[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 1962 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 1963 +[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 1964 +[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 1965 +[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 1966 +[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 1967 +[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 1968 +[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 1969 +[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 1970 +[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 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 s88) +[GOOD] (assert s74) +Fast allSat, Looking for solution 1971 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 2)) +[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 2)) +[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 2)) +[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 2)) +[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 2)) +[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 2)) +[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 2)) +[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 2)) +[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 2)) +[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 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1982 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 s88) +[GOOD] (assert s75) +Fast allSat, Looking for solution 1983 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1984 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1985 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 3)) +[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 3)) +[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 3)) +[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 3)) +[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 3)) +[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 3)) +[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 3)) +[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 3)) +[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 3)) +[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 s76) +Fast allSat, Looking for solution 1995 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1997 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1998 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1999 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 2000 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 2001 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 2002 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 2003 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 2004 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 2005 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2006 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 2007 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s54) +[GOOD] (define-fun s99 () Bool (= s0 s20)) +[GOOD] (assert s99) +Fast allSat, Looking for solution 2007 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s55) +Fast allSat, Looking for solution 2008 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s52) +Fast allSat, Looking for solution 2009 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s51) +Fast allSat, Looking for solution 2010 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s50) +Fast allSat, Looking for solution 2011 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s49) +Fast allSat, Looking for solution 2012 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s48) +Fast allSat, Looking for solution 2013 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s47) +Fast allSat, Looking for solution 2014 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s46) +Fast allSat, Looking for solution 2015 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s45) +Fast allSat, Looking for solution 2016 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s43) +Fast allSat, Looking for solution 2017 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s57) +Fast allSat, Looking for solution 2018 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s87) +Fast allSat, Looking for solution 2019 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s56) +Fast allSat, Looking for solution 2020 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s70) +[GOOD] (assert s73) +Fast allSat, Looking for solution 2020 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 2021 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 2022 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 2023 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 2024 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 2025 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 2026 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 2027 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 2028 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 2029 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 2030 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 2031 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 2032 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s69) +[GOOD] (assert s89) +Fast allSat, Looking for solution 2032 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 2033 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 2034 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 2035 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 2036 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 2037 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 2038 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 2039 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 2040 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 2041 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 2042 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2043 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 2044 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s69) +[GOOD] (assert s59) +Fast allSat, Looking for solution 2044 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 2045 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 2046 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 2047 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 2048 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 2049 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 2050 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 2051 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 2052 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 2053 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 2054 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2055 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 2056 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s69) +[GOOD] (assert s85) +Fast allSat, Looking for solution 2056 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 2057 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 2058 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 2059 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 2060 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 2062 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 2063 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 2064 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 2065 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 2066 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2067 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 2068 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s69) +[GOOD] (assert s84) +Fast allSat, Looking for solution 2068 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 2069 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 2070 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 2071 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 2072 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 2073 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 2074 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 2075 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 2076 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 2077 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 2078 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2079 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 2080 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s69) +[GOOD] (assert s83) +Fast allSat, Looking for solution 2080 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 2081 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 2082 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 2083 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 2084 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 2086 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 2087 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 2088 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 2089 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 2090 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2091 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 2092 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s69) +[GOOD] (assert s82) +Fast allSat, Looking for solution 2092 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 2093 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2094 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 2095 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 2096 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 2097 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 2098 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 2099 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 10)) +[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 10)) +[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 10)) +[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 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 2104 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s69) +[GOOD] (assert s81) +Fast allSat, Looking for solution 2104 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 2105 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 9)) +[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 9)) +[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 9)) +[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 9)) +[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 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 2111 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 2112 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 2113 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 2114 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2115 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 2116 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s69) +[GOOD] (assert s80) +Fast allSat, Looking for solution 2116 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 2117 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2118 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 2119 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 2120 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 2121 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 8)) +[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 8)) +[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 8)) +[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 8)) +[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 8)) +[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 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 2128 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s69) +[GOOD] (assert s79) +Fast allSat, Looking for solution 2128 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 2129 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 7)) +[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 7)) +[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 7)) +[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 7)) +[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 7)) +[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 7)) +[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 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 2137 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 2138 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2139 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 2140 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s69) +[GOOD] (assert s78) +Fast allSat, Looking for solution 2140 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 2141 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2142 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 2143 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 6)) +[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 6)) +[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 6)) +[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 6)) +[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 6)) +[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 6)) +[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 6)) +[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 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 2152 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s69) +[GOOD] (assert s77) +Fast allSat, Looking for solution 2152 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 2153 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 5)) +[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 5)) +[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 5)) +[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 5)) +[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 5)) +[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 5)) +[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 5)) +[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 5)) +[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 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2163 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 2164 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s71) +[GOOD] (assert s74) +Fast allSat, Looking for solution 2164 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +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 s88) +Fast allSat, Looking for solution 2176 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s67) +[GOOD] (assert s99) +[GOOD] (assert s75) +Fast allSat, Looking for solution 2176 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 2177 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 3)) +[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 3)) +[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 3)) +[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 3)) +[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 3)) +[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 3)) +[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 3)) +[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 3)) +[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 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2187 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 2188 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s56) +[GOOD] (define-fun s100 () Bool (= s0 s18)) +[GOOD] (assert s100) +Fast allSat, Looking for solution 2188 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s54) +Fast allSat, Looking for solution 2189 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s53) +Fast allSat, Looking for solution 2190 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s52) +Fast allSat, Looking for solution 2191 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s51) +Fast allSat, Looking for solution 2192 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 s49) +Fast allSat, Looking for solution 2194 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s48) +Fast allSat, Looking for solution 2195 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s47) +Fast allSat, Looking for solution 2196 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s46) +Fast allSat, Looking for solution 2197 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s45) +Fast allSat, Looking for solution 2198 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s43) +Fast allSat, Looking for solution 2199 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 s89) +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 s88) +Fast allSat, Looking for solution 2225 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s71) +[GOOD] (assert s85) +Fast allSat, Looking for solution 2225 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 s88) +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 s84) +Fast allSat, Looking for solution 2237 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 s88) +Fast allSat, Looking for solution 2249 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s71) +[GOOD] (assert s83) +Fast allSat, Looking for solution 2249 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +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 s82) +Fast allSat, Looking for solution 2261 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 s88) +Fast allSat, Looking for solution 2273 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s71) +[GOOD] (assert s81) +Fast allSat, Looking for solution 2273 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +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 s80) +Fast allSat, Looking for solution 2285 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 s88) +Fast allSat, Looking for solution 2297 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert 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 s88) +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 s78) +Fast allSat, Looking for solution 2309 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 s88) +Fast allSat, Looking for solution 2321 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s71) +[GOOD] (assert s77) +Fast allSat, Looking for solution 2321 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +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 s76) +Fast allSat, Looking for solution 2333 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 s88) +Fast allSat, Looking for solution 2345 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s71) +[GOOD] (assert s75) +Fast allSat, Looking for solution 2345 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +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 s73) +Fast allSat, Looking for solution 2357 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 2358 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 2359 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 2360 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 2361 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 2362 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 2363 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 2364 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 2365 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 2366 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 2367 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 2368 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 2369 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s56) +[GOOD] (define-fun s101 () Bool (= s0 s16)) +[GOOD] (assert s101) +Fast allSat, Looking for solution 2369 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s55) +Fast allSat, Looking for solution 2370 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s53) +Fast allSat, Looking for solution 2371 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s52) +Fast allSat, Looking for solution 2372 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s51) +Fast allSat, Looking for solution 2373 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s50) +Fast allSat, Looking for solution 2374 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s49) +Fast allSat, Looking for solution 2375 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s48) +Fast allSat, Looking for solution 2376 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s47) +Fast allSat, Looking for solution 2377 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s46) +Fast allSat, Looking for solution 2378 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s45) +Fast allSat, Looking for solution 2379 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s43) +Fast allSat, Looking for solution 2380 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s57) +Fast allSat, Looking for solution 2381 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s87) +Fast allSat, Looking for solution 2382 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s72) +[GOOD] (assert s89) +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 s88) +[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 s88) +[GOOD] (assert s85) +Fast allSat, Looking for solution 2406 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 2407 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 2408 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 2409 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 2410 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 2411 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 2412 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 2413 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 2414 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 2415 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 s88) +[GOOD] (assert s84) +Fast allSat, Looking for solution 2418 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 s88) +[GOOD] (assert s83) +Fast allSat, Looking for solution 2430 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 s88) +[GOOD] (assert s82) +Fast allSat, Looking for solution 2442 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 s88) +[GOOD] (assert s81) +Fast allSat, Looking for solution 2454 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 s88) +[GOOD] (assert s80) +Fast allSat, Looking for solution 2466 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 s88) +[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 s88) +[GOOD] (assert s78) +Fast allSat, Looking for solution 2490 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 s88) +[GOOD] (assert s77) +Fast allSat, Looking for solution 2502 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 s88) +[GOOD] (assert s76) +Fast allSat, Looking for solution 2514 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 s88) +[GOOD] (assert s74) +Fast allSat, Looking for solution 2526 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 s73) +Fast allSat, Looking for solution 2538 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 s88) +Fast allSat, Looking for solution 2550 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s55) +[GOOD] (define-fun s102 () Bool (= s0 s3)) +[GOOD] (assert s102) +Fast allSat, Looking for solution 2550 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s54) +Fast allSat, Looking for solution 2551 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s53) +Fast allSat, Looking for solution 2552 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s52) +Fast allSat, Looking for solution 2553 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s51) +Fast allSat, Looking for solution 2554 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[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 7)) +[GOOD] (push 1) +[GOOD] (assert s49) +Fast allSat, Looking for solution 2556 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s48) +Fast allSat, Looking for solution 2557 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s47) +Fast allSat, Looking for solution 2558 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s46) +Fast allSat, Looking for solution 2559 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s45) +Fast allSat, Looking for solution 2560 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s43) +Fast allSat, Looking for solution 2561 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[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 s89) +Fast allSat, Looking for solution 2563 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert 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 s58) +[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 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +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 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +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 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +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 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 2579 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +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 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +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 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 2583 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 2584 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 2585 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2586 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 2587 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s60) +[GOOD] (assert s85) +Fast allSat, Looking for solution 2587 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +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 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +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 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 2590 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 2591 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 2592 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +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 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +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 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +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 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +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 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2597 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 2598 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 2599 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s61) +[GOOD] (assert s84) +Fast allSat, Looking for solution 2599 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +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 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +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 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +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 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 2603 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +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 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +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 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +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 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +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 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2608 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 2609 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 2610 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 2611 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s62) +[GOOD] (assert s83) +Fast allSat, Looking for solution 2611 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +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 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +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 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 2614 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +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 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +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 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +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 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +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 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2619 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 2620 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 2621 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 2622 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 2623 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s63) +[GOOD] (assert s82) +Fast allSat, Looking for solution 2623 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +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 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 2625 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +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 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +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 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +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 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +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 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2630 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 2631 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 2632 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 2633 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 2634 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 2635 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s64) +[GOOD] (assert s81) +Fast allSat, Looking for solution 2635 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 2636 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +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 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +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 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +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 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +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 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2641 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 2642 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 2643 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 2644 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 2645 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 2646 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 2647 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s65) +[GOOD] (assert s80) +Fast allSat, Looking for solution 2647 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +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 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 2649 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +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 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +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 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2652 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 2653 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 2654 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 2655 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 2656 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 2657 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 2658 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 2659 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s66) +[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 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +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 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +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 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +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 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2663 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 2664 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 2665 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 2666 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 2667 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 2668 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 2669 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 2670 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 2671 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s67) +[GOOD] (assert s78) +Fast allSat, Looking for solution 2671 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +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 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +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 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2674 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 2675 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 2676 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 2677 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 2678 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 2679 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 2680 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 2681 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 2682 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 2683 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s68) +[GOOD] (assert s77) +Fast allSat, Looking for solution 2683 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s69) +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 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2685 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 2686 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 2687 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 2688 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 2689 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 2690 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 2691 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 2692 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 2693 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 2694 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 2695 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s69) +[GOOD] (assert s76) +Fast allSat, Looking for solution 2695 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2696 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 2697 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 2698 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 2699 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 2700 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 2701 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 2702 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 2703 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 2704 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 2705 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 2706 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 2707 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s70) +[GOOD] (assert s75) +Fast allSat, Looking for solution 2707 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s68) +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 5)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 2709 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s66) +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 7)) +[GOOD] (push 1) +[GOOD] (assert s65) +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 8)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 2712 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 2713 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 2714 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 2715 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 2716 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 2717 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 2718 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 2719 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s69) +[GOOD] (assert s102) +[GOOD] (assert s74) +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 s88) Fast allSat, Looking for solution 2731 [SEND] (check-sat) [RECV] unsat diff --git a/SBVTestSuite/GoldFiles/allSat8.gold b/SBVTestSuite/GoldFiles/allSat8.gold --- a/SBVTestSuite/GoldFiles/allSat8.gold +++ b/SBVTestSuite/GoldFiles/allSat8.gold @@ -59,5 +59,3 @@ *** *** NB. If this is a use case you'd like SBV to support, please get in touch! -CallStack (from HasCallStack): - error, called at ./Data/SBV/Control/Utils.hs:1647:57 in sbv-11.0-inplace:Data.SBV.Control.Utils diff --git a/SBVTestSuite/GoldFiles/arbFp_opt_1.gold b/SBVTestSuite/GoldFiles/arbFp_opt_1.gold --- a/SBVTestSuite/GoldFiles/arbFp_opt_1.gold +++ b/SBVTestSuite/GoldFiles/arbFp_opt_1.gold @@ -1,4 +1,4 @@ Optimal model: - x = 65504.0 :: FloatingPoint 5 11 s0 = 65504.0 :: FloatingPoint 5 11 toMetricSpace(x) = 64511 :: Word16 + x = 65504.0 :: FloatingPoint 5 11 diff --git a/SBVTestSuite/GoldFiles/concreteFoldl.gold b/SBVTestSuite/GoldFiles/concreteFoldl.gold deleted file mode 100644 --- a/SBVTestSuite/GoldFiles/concreteFoldl.gold +++ /dev/null @@ -1,24 +0,0 @@ -** Calling: z3 -nw -in -smt2 -[GOOD] ; Automatically generated by SBV. Do not edit. -[GOOD] (set-option :print-success true) -[GOOD] (set-option :global-declarations true) -[GOOD] (set-option :smtlib2_compliant true) -[GOOD] (set-option :diagnostic-output-channel "stdout") -[GOOD] (set-option :produce-models true) -[GOOD] (set-logic ALL) ; external query, using all logics. -[GOOD] ; --- uninterpreted sorts --- -[GOOD] ; --- tuples --- -[GOOD] ; --- sums --- -[GOOD] ; --- literal constants --- -[GOOD] ; --- top level inputs --- -[GOOD] ; --- constant tables --- -[GOOD] ; --- non-constant tables --- -[GOOD] ; --- uninterpreted constants --- -[GOOD] ; --- user defined functions --- -[GOOD] ; --- assignments --- -[GOOD] ; --- delayedEqualities --- -[GOOD] ; --- formula --- -[SEND] (check-sat) -[RECV] sat -*** Solver : Z3 -*** Exit code: ExitSuccess diff --git a/SBVTestSuite/GoldFiles/concreteFoldr.gold b/SBVTestSuite/GoldFiles/concreteFoldr.gold deleted file mode 100644 --- a/SBVTestSuite/GoldFiles/concreteFoldr.gold +++ /dev/null @@ -1,24 +0,0 @@ -** Calling: z3 -nw -in -smt2 -[GOOD] ; Automatically generated by SBV. Do not edit. -[GOOD] (set-option :print-success true) -[GOOD] (set-option :global-declarations true) -[GOOD] (set-option :smtlib2_compliant true) -[GOOD] (set-option :diagnostic-output-channel "stdout") -[GOOD] (set-option :produce-models true) -[GOOD] (set-logic ALL) ; external query, using all logics. -[GOOD] ; --- uninterpreted sorts --- -[GOOD] ; --- tuples --- -[GOOD] ; --- sums --- -[GOOD] ; --- literal constants --- -[GOOD] ; --- top level inputs --- -[GOOD] ; --- constant tables --- -[GOOD] ; --- non-constant tables --- -[GOOD] ; --- uninterpreted constants --- -[GOOD] ; --- user defined functions --- -[GOOD] ; --- assignments --- -[GOOD] ; --- delayedEqualities --- -[GOOD] ; --- formula --- -[SEND] (check-sat) -[RECV] sat -*** Solver : Z3 -*** Exit code: ExitSuccess diff --git a/SBVTestSuite/GoldFiles/concreteReverse.gold b/SBVTestSuite/GoldFiles/concreteReverse.gold deleted file mode 100644 --- a/SBVTestSuite/GoldFiles/concreteReverse.gold +++ /dev/null @@ -1,24 +0,0 @@ -** Calling: z3 -nw -in -smt2 -[GOOD] ; Automatically generated by SBV. Do not edit. -[GOOD] (set-option :print-success true) -[GOOD] (set-option :global-declarations true) -[GOOD] (set-option :smtlib2_compliant true) -[GOOD] (set-option :diagnostic-output-channel "stdout") -[GOOD] (set-option :produce-models true) -[GOOD] (set-logic ALL) ; external query, using all logics. -[GOOD] ; --- uninterpreted sorts --- -[GOOD] ; --- tuples --- -[GOOD] ; --- sums --- -[GOOD] ; --- literal constants --- -[GOOD] ; --- top level inputs --- -[GOOD] ; --- constant tables --- -[GOOD] ; --- non-constant tables --- -[GOOD] ; --- uninterpreted constants --- -[GOOD] ; --- user defined functions --- -[GOOD] ; --- assignments --- -[GOOD] ; --- delayedEqualities --- -[GOOD] ; --- formula --- -[SEND] (check-sat) -[RECV] sat -*** Solver : Z3 -*** Exit code: ExitSuccess diff --git a/SBVTestSuite/GoldFiles/concreteSort.gold b/SBVTestSuite/GoldFiles/concreteSort.gold deleted file mode 100644 --- a/SBVTestSuite/GoldFiles/concreteSort.gold +++ /dev/null @@ -1,24 +0,0 @@ -** Calling: z3 -nw -in -smt2 -[GOOD] ; Automatically generated by SBV. Do not edit. -[GOOD] (set-option :print-success true) -[GOOD] (set-option :global-declarations true) -[GOOD] (set-option :smtlib2_compliant true) -[GOOD] (set-option :diagnostic-output-channel "stdout") -[GOOD] (set-option :produce-models true) -[GOOD] (set-logic ALL) ; external query, using all logics. -[GOOD] ; --- uninterpreted sorts --- -[GOOD] ; --- tuples --- -[GOOD] ; --- sums --- -[GOOD] ; --- literal constants --- -[GOOD] ; --- top level inputs --- -[GOOD] ; --- constant tables --- -[GOOD] ; --- non-constant tables --- -[GOOD] ; --- uninterpreted constants --- -[GOOD] ; --- user defined functions --- -[GOOD] ; --- assignments --- -[GOOD] ; --- delayedEqualities --- -[GOOD] ; --- formula --- -[SEND] (check-sat) -[RECV] sat -*** Solver : Z3 -*** Exit code: ExitSuccess diff --git a/SBVTestSuite/GoldFiles/doctest_sanity.gold b/SBVTestSuite/GoldFiles/doctest_sanity.gold new file mode 100644 --- /dev/null +++ b/SBVTestSuite/GoldFiles/doctest_sanity.gold @@ -0,0 +1,3 @@ +Total: 907; Tried: 907; Skipped: 0; Success: 907; Errors: 0; Failures 0 +Examples: 784; Tried: 784; Skipped: 0; Success: 784; Errors: 0; Failures 0 +Setup: 123; Tried: 123; Skipped: 0; Success: 123; Errors: 0; Failures 0 diff --git a/SBVTestSuite/GoldFiles/foldlABC1.gold b/SBVTestSuite/GoldFiles/foldlABC1.gold deleted file mode 100644 --- a/SBVTestSuite/GoldFiles/foldlABC1.gold +++ /dev/null @@ -1,50 +0,0 @@ -** 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-option :pp.max_depth 4294967295) -[GOOD] (set-option :pp.min_alias_size 4294967295) -[GOOD] (set-option :model.inline_def 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 0) -[GOOD] ; --- top level inputs --- -[GOOD] (declare-fun s0 () Int) ; tracks user variable "a" -[GOOD] (declare-fun s1 () Int) ; tracks user variable "b" -[GOOD] (declare-fun s2 () Int) ; tracks user variable "c" -[GOOD] ; --- constant tables --- -[GOOD] ; --- non-constant tables --- -[GOOD] ; --- uninterpreted constants --- -[GOOD] ; --- user defined functions --- -[GOOD] ; --- assignments --- -[GOOD] (define-fun s4 () Bool (> s0 s3)) -[GOOD] (define-fun s5 () Bool (> s1 s3)) -[GOOD] (define-fun s6 () Bool (> s2 s3)) -[GOOD] (define-fun s7 () (Seq Int) (seq.unit s0)) -[GOOD] (define-fun s8 () (Seq Int) (seq.unit s1)) -[GOOD] (define-fun s9 () (Seq Int) (seq.unit s2)) -[GOOD] (define-fun s10 () (Seq Int) (seq.++ s8 s9)) -[GOOD] (define-fun s11 () (Seq Int) (seq.++ s7 s10)) -[GOOD] (define-fun s12 () Int (seq.len s11)) -[GOOD] (define-fun s13 () Bool (= s3 s12)) -[GOOD] (define-fun s14 () Int (seq.nth s11 s3)) -[GOOD] (define-fun s15 () Int (ite s13 s3 s14)) -[GOOD] (define-fun s16 () Int (+ s0 s1)) -[GOOD] (define-fun s17 () Int (+ s2 s16)) -[GOOD] (define-fun s18 () Bool (= s15 s17)) -[GOOD] ; --- delayedEqualities --- -[GOOD] ; --- formula --- -[GOOD] (assert s4) -[GOOD] (assert s5) -[GOOD] (assert s6) -[GOOD] (assert s18) -[SEND] (check-sat) -[RECV] unsat -*** Solver : Z3 -*** Exit code: ExitSuccess diff --git a/SBVTestSuite/GoldFiles/foldlABC2.gold b/SBVTestSuite/GoldFiles/foldlABC2.gold deleted file mode 100644 --- a/SBVTestSuite/GoldFiles/foldlABC2.gold +++ /dev/null @@ -1,58 +0,0 @@ -** 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-option :pp.max_depth 4294967295) -[GOOD] (set-option :pp.min_alias_size 4294967295) -[GOOD] (set-option :model.inline_def 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 0) -[GOOD] (define-fun s15 () Int 1) -[GOOD] ; --- top level inputs --- -[GOOD] (declare-fun s0 () Int) ; tracks user variable "a" -[GOOD] (declare-fun s1 () Int) ; tracks user variable "b" -[GOOD] (declare-fun s2 () Int) ; tracks user variable "c" -[GOOD] ; --- constant tables --- -[GOOD] ; --- non-constant tables --- -[GOOD] ; --- uninterpreted constants --- -[GOOD] ; --- user defined functions --- -[GOOD] ; --- assignments --- -[GOOD] (define-fun s4 () Bool (> s0 s3)) -[GOOD] (define-fun s5 () Bool (> s1 s3)) -[GOOD] (define-fun s6 () Bool (> s2 s3)) -[GOOD] (define-fun s7 () (Seq Int) (seq.unit s0)) -[GOOD] (define-fun s8 () (Seq Int) (seq.unit s1)) -[GOOD] (define-fun s9 () (Seq Int) (seq.unit s2)) -[GOOD] (define-fun s10 () (Seq Int) (seq.++ s8 s9)) -[GOOD] (define-fun s11 () (Seq Int) (seq.++ s7 s10)) -[GOOD] (define-fun s12 () Int (seq.len s11)) -[GOOD] (define-fun s13 () Bool (= s3 s12)) -[GOOD] (define-fun s14 () Int (seq.nth s11 s3)) -[GOOD] (define-fun s16 () Int (- s12 s15)) -[GOOD] (define-fun s17 () (Seq Int) (seq.extract s11 s15 s16)) -[GOOD] (define-fun s18 () Int (seq.len s17)) -[GOOD] (define-fun s19 () Bool (= s3 s18)) -[GOOD] (define-fun s20 () Int (seq.nth s17 s3)) -[GOOD] (define-fun s21 () Int (ite s19 s3 s20)) -[GOOD] (define-fun s22 () Int (+ s14 s21)) -[GOOD] (define-fun s23 () Int (ite s13 s3 s22)) -[GOOD] (define-fun s24 () Int (+ s0 s1)) -[GOOD] (define-fun s25 () Int (+ s2 s24)) -[GOOD] (define-fun s26 () Bool (= s23 s25)) -[GOOD] ; --- delayedEqualities --- -[GOOD] ; --- formula --- -[GOOD] (assert s4) -[GOOD] (assert s5) -[GOOD] (assert s6) -[GOOD] (assert s26) -[SEND] (check-sat) -[RECV] unsat -*** Solver : Z3 -*** Exit code: ExitSuccess diff --git a/SBVTestSuite/GoldFiles/foldlABC3.gold b/SBVTestSuite/GoldFiles/foldlABC3.gold deleted file mode 100644 --- a/SBVTestSuite/GoldFiles/foldlABC3.gold +++ /dev/null @@ -1,65 +0,0 @@ -** 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-option :pp.max_depth 4294967295) -[GOOD] (set-option :pp.min_alias_size 4294967295) -[GOOD] (set-option :model.inline_def 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 0) -[GOOD] (define-fun s15 () Int 1) -[GOOD] ; --- top level inputs --- -[GOOD] (declare-fun s0 () Int) ; tracks user variable "a" -[GOOD] (declare-fun s1 () Int) ; tracks user variable "b" -[GOOD] (declare-fun s2 () Int) ; tracks user variable "c" -[GOOD] ; --- constant tables --- -[GOOD] ; --- non-constant tables --- -[GOOD] ; --- uninterpreted constants --- -[GOOD] ; --- user defined functions --- -[GOOD] ; --- assignments --- -[GOOD] (define-fun s4 () Bool (> s0 s3)) -[GOOD] (define-fun s5 () Bool (> s1 s3)) -[GOOD] (define-fun s6 () Bool (> s2 s3)) -[GOOD] (define-fun s7 () (Seq Int) (seq.unit s0)) -[GOOD] (define-fun s8 () (Seq Int) (seq.unit s1)) -[GOOD] (define-fun s9 () (Seq Int) (seq.unit s2)) -[GOOD] (define-fun s10 () (Seq Int) (seq.++ s8 s9)) -[GOOD] (define-fun s11 () (Seq Int) (seq.++ s7 s10)) -[GOOD] (define-fun s12 () Int (seq.len s11)) -[GOOD] (define-fun s13 () Bool (= s3 s12)) -[GOOD] (define-fun s14 () Int (seq.nth s11 s3)) -[GOOD] (define-fun s16 () Int (- s12 s15)) -[GOOD] (define-fun s17 () (Seq Int) (seq.extract s11 s15 s16)) -[GOOD] (define-fun s18 () Int (seq.len s17)) -[GOOD] (define-fun s19 () Bool (= s3 s18)) -[GOOD] (define-fun s20 () Int (seq.nth s17 s3)) -[GOOD] (define-fun s21 () Int (- s18 s15)) -[GOOD] (define-fun s22 () (Seq Int) (seq.extract s17 s15 s21)) -[GOOD] (define-fun s23 () Int (seq.len s22)) -[GOOD] (define-fun s24 () Bool (= s3 s23)) -[GOOD] (define-fun s25 () Int (seq.nth s22 s3)) -[GOOD] (define-fun s26 () Int (ite s24 s3 s25)) -[GOOD] (define-fun s27 () Int (+ s20 s26)) -[GOOD] (define-fun s28 () Int (ite s19 s3 s27)) -[GOOD] (define-fun s29 () Int (+ s14 s28)) -[GOOD] (define-fun s30 () Int (ite s13 s3 s29)) -[GOOD] (define-fun s31 () Int (+ s0 s1)) -[GOOD] (define-fun s32 () Int (+ s2 s31)) -[GOOD] (define-fun s33 () Bool (= s30 s32)) -[GOOD] ; --- delayedEqualities --- -[GOOD] ; --- formula --- -[GOOD] (assert s4) -[GOOD] (assert s5) -[GOOD] (assert s6) -[GOOD] (assert s33) -[SEND] (check-sat) -[RECV] sat -*** Solver : Z3 -*** Exit code: ExitSuccess diff --git a/SBVTestSuite/GoldFiles/foldrAB1.gold b/SBVTestSuite/GoldFiles/foldrAB1.gold deleted file mode 100644 --- a/SBVTestSuite/GoldFiles/foldrAB1.gold +++ /dev/null @@ -1,44 +0,0 @@ -** 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-option :pp.max_depth 4294967295) -[GOOD] (set-option :pp.min_alias_size 4294967295) -[GOOD] (set-option :model.inline_def true ) -[GOOD] (set-logic ALL) ; has unbounded values, using catch-all. -[GOOD] ; --- uninterpreted sorts --- -[GOOD] ; --- tuples --- -[GOOD] ; --- sums --- -[GOOD] ; --- literal constants --- -[GOOD] (define-fun s2 () Int 0) -[GOOD] ; --- top level inputs --- -[GOOD] (declare-fun s0 () Int) ; tracks user variable "a" -[GOOD] (declare-fun s1 () Int) ; tracks user variable "b" -[GOOD] ; --- constant tables --- -[GOOD] ; --- non-constant tables --- -[GOOD] ; --- uninterpreted constants --- -[GOOD] ; --- user defined functions --- -[GOOD] ; --- assignments --- -[GOOD] (define-fun s3 () Bool (> s0 s2)) -[GOOD] (define-fun s4 () Bool (> s1 s2)) -[GOOD] (define-fun s5 () (Seq Int) (seq.unit s0)) -[GOOD] (define-fun s6 () (Seq Int) (seq.unit s1)) -[GOOD] (define-fun s7 () (Seq Int) (seq.++ s5 s6)) -[GOOD] (define-fun s8 () Int (seq.len s7)) -[GOOD] (define-fun s9 () Bool (= s2 s8)) -[GOOD] (define-fun s10 () Int (seq.nth s7 s2)) -[GOOD] (define-fun s11 () Int (ite s9 s2 s10)) -[GOOD] (define-fun s12 () Int (+ s0 s1)) -[GOOD] (define-fun s13 () Bool (= s11 s12)) -[GOOD] ; --- delayedEqualities --- -[GOOD] ; --- formula --- -[GOOD] (assert s3) -[GOOD] (assert s4) -[GOOD] (assert s13) -[SEND] (check-sat) -[RECV] unsat -*** Solver : Z3 -*** Exit code: ExitSuccess diff --git a/SBVTestSuite/GoldFiles/foldrAB2.gold b/SBVTestSuite/GoldFiles/foldrAB2.gold deleted file mode 100644 --- a/SBVTestSuite/GoldFiles/foldrAB2.gold +++ /dev/null @@ -1,52 +0,0 @@ -** 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-option :pp.max_depth 4294967295) -[GOOD] (set-option :pp.min_alias_size 4294967295) -[GOOD] (set-option :model.inline_def true ) -[GOOD] (set-logic ALL) ; has unbounded values, using catch-all. -[GOOD] ; --- uninterpreted sorts --- -[GOOD] ; --- tuples --- -[GOOD] ; --- sums --- -[GOOD] ; --- literal constants --- -[GOOD] (define-fun s2 () Int 0) -[GOOD] (define-fun s11 () Int 1) -[GOOD] ; --- top level inputs --- -[GOOD] (declare-fun s0 () Int) ; tracks user variable "a" -[GOOD] (declare-fun s1 () Int) ; tracks user variable "b" -[GOOD] ; --- constant tables --- -[GOOD] ; --- non-constant tables --- -[GOOD] ; --- uninterpreted constants --- -[GOOD] ; --- user defined functions --- -[GOOD] ; --- assignments --- -[GOOD] (define-fun s3 () Bool (> s0 s2)) -[GOOD] (define-fun s4 () Bool (> s1 s2)) -[GOOD] (define-fun s5 () (Seq Int) (seq.unit s0)) -[GOOD] (define-fun s6 () (Seq Int) (seq.unit s1)) -[GOOD] (define-fun s7 () (Seq Int) (seq.++ s5 s6)) -[GOOD] (define-fun s8 () Int (seq.len s7)) -[GOOD] (define-fun s9 () Bool (= s2 s8)) -[GOOD] (define-fun s10 () Int (seq.nth s7 s2)) -[GOOD] (define-fun s12 () Int (- s8 s11)) -[GOOD] (define-fun s13 () (Seq Int) (seq.extract s7 s11 s12)) -[GOOD] (define-fun s14 () Int (seq.len s13)) -[GOOD] (define-fun s15 () Bool (= s2 s14)) -[GOOD] (define-fun s16 () Int (seq.nth s13 s2)) -[GOOD] (define-fun s17 () Int (ite s15 s2 s16)) -[GOOD] (define-fun s18 () Int (+ s10 s17)) -[GOOD] (define-fun s19 () Int (ite s9 s2 s18)) -[GOOD] (define-fun s20 () Int (+ s0 s1)) -[GOOD] (define-fun s21 () Bool (= s19 s20)) -[GOOD] ; --- delayedEqualities --- -[GOOD] ; --- formula --- -[GOOD] (assert s3) -[GOOD] (assert s4) -[GOOD] (assert s21) -[SEND] (check-sat) -[RECV] sat -*** Solver : Z3 -*** Exit code: ExitSuccess diff --git a/SBVTestSuite/GoldFiles/foldrAB3.gold b/SBVTestSuite/GoldFiles/foldrAB3.gold deleted file mode 100644 --- a/SBVTestSuite/GoldFiles/foldrAB3.gold +++ /dev/null @@ -1,59 +0,0 @@ -** 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-option :pp.max_depth 4294967295) -[GOOD] (set-option :pp.min_alias_size 4294967295) -[GOOD] (set-option :model.inline_def true ) -[GOOD] (set-logic ALL) ; has unbounded values, using catch-all. -[GOOD] ; --- uninterpreted sorts --- -[GOOD] ; --- tuples --- -[GOOD] ; --- sums --- -[GOOD] ; --- literal constants --- -[GOOD] (define-fun s2 () Int 0) -[GOOD] (define-fun s11 () Int 1) -[GOOD] ; --- top level inputs --- -[GOOD] (declare-fun s0 () Int) ; tracks user variable "a" -[GOOD] (declare-fun s1 () Int) ; tracks user variable "b" -[GOOD] ; --- constant tables --- -[GOOD] ; --- non-constant tables --- -[GOOD] ; --- uninterpreted constants --- -[GOOD] ; --- user defined functions --- -[GOOD] ; --- assignments --- -[GOOD] (define-fun s3 () Bool (> s0 s2)) -[GOOD] (define-fun s4 () Bool (> s1 s2)) -[GOOD] (define-fun s5 () (Seq Int) (seq.unit s0)) -[GOOD] (define-fun s6 () (Seq Int) (seq.unit s1)) -[GOOD] (define-fun s7 () (Seq Int) (seq.++ s5 s6)) -[GOOD] (define-fun s8 () Int (seq.len s7)) -[GOOD] (define-fun s9 () Bool (= s2 s8)) -[GOOD] (define-fun s10 () Int (seq.nth s7 s2)) -[GOOD] (define-fun s12 () Int (- s8 s11)) -[GOOD] (define-fun s13 () (Seq Int) (seq.extract s7 s11 s12)) -[GOOD] (define-fun s14 () Int (seq.len s13)) -[GOOD] (define-fun s15 () Bool (= s2 s14)) -[GOOD] (define-fun s16 () Int (seq.nth s13 s2)) -[GOOD] (define-fun s17 () Int (- s14 s11)) -[GOOD] (define-fun s18 () (Seq Int) (seq.extract s13 s11 s17)) -[GOOD] (define-fun s19 () Int (seq.len s18)) -[GOOD] (define-fun s20 () Bool (= s2 s19)) -[GOOD] (define-fun s21 () Int (seq.nth s18 s2)) -[GOOD] (define-fun s22 () Int (ite s20 s2 s21)) -[GOOD] (define-fun s23 () Int (+ s16 s22)) -[GOOD] (define-fun s24 () Int (ite s15 s2 s23)) -[GOOD] (define-fun s25 () Int (+ s10 s24)) -[GOOD] (define-fun s26 () Int (ite s9 s2 s25)) -[GOOD] (define-fun s27 () Int (+ s0 s1)) -[GOOD] (define-fun s28 () Bool (= s26 s27)) -[GOOD] ; --- delayedEqualities --- -[GOOD] ; --- formula --- -[GOOD] (assert s3) -[GOOD] (assert s4) -[GOOD] (assert s28) -[SEND] (check-sat) -[RECV] sat -*** Solver : Z3 -*** Exit code: ExitSuccess diff --git a/SBVTestSuite/GoldFiles/lambda04.gold b/SBVTestSuite/GoldFiles/lambda04.gold --- a/SBVTestSuite/GoldFiles/lambda04.gold +++ b/SBVTestSuite/GoldFiles/lambda04.gold @@ -8,7 +8,7 @@ [GOOD] (set-option :pp.max_depth 4294967295) [GOOD] (set-option :pp.min_alias_size 4294967295) [GOOD] (set-option :model.inline_def true ) -[GOOD] (set-logic ALL) ; has unbounded values, using catch-all. +[GOOD] (set-logic ALL) ; has lambda expressions, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums --- @@ -20,11 +20,18 @@ [GOOD] ; --- constant tables --- [GOOD] ; --- non-constant tables --- [GOOD] ; --- uninterpreted constants --- +[GOOD] ; --- Firstified function definitions +[GOOD] ; Firstified function: map :: (SInteger -> SBool) -> [SInteger] -> [SBool] +[GOOD] (define-fun-rec sbv.map_a4ae08 ((lst (Seq Int))) (Seq Bool) + (ite (= lst (as seq.empty (Seq Int))) + (as seq.empty (Seq Bool)) + (seq.++ (seq.unit (select (lambda ((args0 Int)) + false) (seq.nth lst 0))) + (sbv.map_a4ae08 (seq.extract lst 1 (- (seq.len lst) 1)))))) [GOOD] ; --- user defined functions --- [GOOD] ; --- assignments --- [GOOD] (define-fun s3 () Bool (= s0 s2)) -[GOOD] (define-fun s4 () (Seq Bool) (seq.map (lambda ((l1_s0 Int)) - false) s0)) +[GOOD] (define-fun s4 () (Seq Bool) (sbv.map_a4ae08 s0)) [GOOD] (define-fun s5 () Bool (= s1 s4)) [GOOD] ; --- delayedEqualities --- [GOOD] ; --- formula --- diff --git a/SBVTestSuite/GoldFiles/lambda05.gold b/SBVTestSuite/GoldFiles/lambda05.gold --- a/SBVTestSuite/GoldFiles/lambda05.gold +++ b/SBVTestSuite/GoldFiles/lambda05.gold @@ -8,7 +8,7 @@ [GOOD] (set-option :pp.max_depth 4294967295) [GOOD] (set-option :pp.min_alias_size 4294967295) [GOOD] (set-option :model.inline_def true ) -[GOOD] (set-logic ALL) ; has unbounded values, using catch-all. +[GOOD] (set-logic ALL) ; has lambda expressions, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums --- @@ -20,17 +20,31 @@ [GOOD] ; --- constant tables --- [GOOD] ; --- non-constant tables --- [GOOD] ; --- uninterpreted constants --- +[GOOD] ; --- Firstified function definitions +[GOOD] ; Firstified function: map :: (SInteger -> SInteger) -> [SInteger] -> [SInteger] +[GOOD] (define-fun-rec sbv.map_58ac1e ((lst (Seq Int))) (Seq Int) + (ite (= lst (as seq.empty (Seq Int))) + (as seq.empty (Seq Int)) + (seq.++ (seq.unit (select (lambda ((args0 Int)) + (let ((args1 2)) + (let ((args2 (+ args0 args1))) + args2))) (seq.nth lst 0))) + (sbv.map_58ac1e (seq.extract lst 1 (- (seq.len lst) 1)))))) +[GOOD] ; Firstified function: map :: (SInteger -> SInteger) -> [SInteger] -> [SInteger] +[GOOD] (define-fun-rec sbv.map_72c5bf ((lst (Seq Int))) (Seq Int) + (ite (= lst (as seq.empty (Seq Int))) + (as seq.empty (Seq Int)) + (seq.++ (seq.unit (select (lambda ((args0 Int)) + (let ((args1 1)) + (let ((args2 (+ args0 args1))) + args2))) (seq.nth lst 0))) + (sbv.map_72c5bf (seq.extract lst 1 (- (seq.len lst) 1)))))) +[GOOD] ; -- NB. Skipping firstified equivalences, due to generateHOEquivs setting. [GOOD] ; --- user defined functions --- [GOOD] ; --- assignments --- [GOOD] (define-fun s3 () Bool (= s0 s2)) -[GOOD] (define-fun s4 () (Seq Int) (seq.map (lambda ((l1_s0 Int)) - (let ((l1_s1 2)) - (let ((l1_s2 (+ l1_s0 l1_s1))) - l1_s2))) s0)) -[GOOD] (define-fun s5 () (Seq Int) (seq.map (lambda ((l1_s0 Int)) - (let ((l1_s1 1)) - (let ((l1_s2 (+ l1_s0 l1_s1))) - l1_s2))) s4)) +[GOOD] (define-fun s4 () (Seq Int) (sbv.map_58ac1e s0)) +[GOOD] (define-fun s5 () (Seq Int) (sbv.map_72c5bf s4)) [GOOD] (define-fun s6 () Bool (= s1 s5)) [GOOD] ; --- delayedEqualities --- [GOOD] ; --- formula --- diff --git a/SBVTestSuite/GoldFiles/lambda06.gold b/SBVTestSuite/GoldFiles/lambda06.gold --- a/SBVTestSuite/GoldFiles/lambda06.gold +++ b/SBVTestSuite/GoldFiles/lambda06.gold @@ -8,7 +8,7 @@ [GOOD] (set-option :pp.max_depth 4294967295) [GOOD] (set-option :pp.min_alias_size 4294967295) [GOOD] (set-option :model.inline_def true ) -[GOOD] (set-logic ALL) ; has unbounded values, using catch-all. +[GOOD] (set-logic ALL) ; has lambda expressions, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums --- @@ -20,29 +20,36 @@ [GOOD] ; --- constant tables --- [GOOD] ; --- non-constant tables --- [GOOD] ; --- uninterpreted constants --- +[GOOD] ; --- Firstified function definitions +[GOOD] ; Firstified function: map :: (SInteger -> SInteger) -> [SInteger] -> [SInteger] +[GOOD] (define-fun-rec sbv.map_066528 ((lst (Seq Int))) (Seq Int) + (ite (= lst (as seq.empty (Seq Int))) + (as seq.empty (Seq Int)) + (seq.++ (seq.unit (select (lambda ((args0 Int)) + (let ((args1 (* args0 args0))) + (let ((args2 (+ args0 args1))) + (let ((args3 (* args0 args1))) + (let ((args4 (+ args2 args3))) + (let ((args5 (* args1 args1))) + (let ((args6 (+ args4 args5))) + (let ((args7 (* args0 args5))) + (let ((args8 (+ args6 args7))) + (let ((args9 (* args1 args5))) + (let ((args10 (+ args8 args9))) + (let ((args11 (* args0 args9))) + (let ((args12 (+ args10 args11))) + (let ((args13 (* args5 args5))) + (let ((args14 (+ args12 args13))) + (let ((args15 (* args0 args13))) + (let ((args16 (+ args14 args15))) + (let ((args17 (* args1 args13))) + (let ((args18 (+ args16 args17))) + args18))))))))))))))))))) (seq.nth lst 0))) + (sbv.map_066528 (seq.extract lst 1 (- (seq.len lst) 1)))))) [GOOD] ; --- user defined functions --- [GOOD] ; --- assignments --- [GOOD] (define-fun s3 () Bool (= s0 s2)) -[GOOD] (define-fun s4 () (Seq Int) (seq.map (lambda ((l1_s0 Int)) - (let ((l1_s1 (* l1_s0 l1_s0))) - (let ((l1_s2 (+ l1_s0 l1_s1))) - (let ((l1_s3 (* l1_s0 l1_s1))) - (let ((l1_s4 (+ l1_s2 l1_s3))) - (let ((l1_s5 (* l1_s1 l1_s1))) - (let ((l1_s6 (+ l1_s4 l1_s5))) - (let ((l1_s7 (* l1_s0 l1_s5))) - (let ((l1_s8 (+ l1_s6 l1_s7))) - (let ((l1_s9 (* l1_s1 l1_s5))) - (let ((l1_s10 (+ l1_s8 l1_s9))) - (let ((l1_s11 (* l1_s0 l1_s9))) - (let ((l1_s12 (+ l1_s10 l1_s11))) - (let ((l1_s13 (* l1_s5 l1_s5))) - (let ((l1_s14 (+ l1_s12 l1_s13))) - (let ((l1_s15 (* l1_s0 l1_s13))) - (let ((l1_s16 (+ l1_s14 l1_s15))) - (let ((l1_s17 (* l1_s1 l1_s13))) - (let ((l1_s18 (+ l1_s16 l1_s17))) - l1_s18))))))))))))))))))) s0)) +[GOOD] (define-fun s4 () (Seq Int) (sbv.map_066528 s0)) [GOOD] (define-fun s5 () Bool (= s1 s4)) [GOOD] ; --- delayedEqualities --- [GOOD] ; --- formula --- diff --git a/SBVTestSuite/GoldFiles/lambda07.gold b/SBVTestSuite/GoldFiles/lambda07.gold --- a/SBVTestSuite/GoldFiles/lambda07.gold +++ b/SBVTestSuite/GoldFiles/lambda07.gold @@ -1,86 +1,10 @@ -** 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-option :pp.max_depth 4294967295) -[GOOD] (set-option :pp.min_alias_size 4294967295) -[GOOD] (set-option :model.inline_def true ) -[GOOD] (set-logic ALL) ; has unbounded values, using catch-all. -[GOOD] ; --- uninterpreted sorts --- -[GOOD] ; --- tuples --- -[GOOD] ; --- sums --- -[GOOD] ; --- literal constants --- -[GOOD] (define-fun s2 () (Seq (Seq Int)) (seq.++ (seq.unit (seq.++ (seq.unit 1) (seq.unit 2) (seq.unit 3) (seq.unit 4) (seq.unit 5))) (seq.unit (seq.++ (seq.unit 1) (seq.unit 2) (seq.unit 3) (seq.unit 4) (seq.unit 5) (seq.unit 6) (seq.unit 7) (seq.unit 8) (seq.unit 9) (seq.unit 10))) (seq.unit (seq.++ (seq.unit 1) (seq.unit 2) (seq.unit 3) (seq.unit 4) (seq.unit 5) (seq.unit 6) (seq.unit 7) (seq.unit 8) (seq.unit 9) (seq.unit 10) (seq.unit 11) (seq.unit 12) (seq.unit 13) (seq.unit 14) (seq.unit 15) (seq.unit 16) (seq.unit 17) (seq.unit 18) (seq.unit 19) (seq.unit 20))))) -[GOOD] (define-fun s4 () Int 0) -[GOOD] ; --- top level inputs --- -[GOOD] (declare-fun s0 () (Seq (Seq Int))) -[GOOD] (declare-fun s1 () Int) -[GOOD] ; --- constant tables --- -[GOOD] ; --- non-constant tables --- -[GOOD] ; --- uninterpreted constants --- -[GOOD] ; --- user defined functions --- -[GOOD] ; --- assignments --- -[GOOD] (define-fun s3 () Bool (= s0 s2)) -[GOOD] (define-fun s5 () (Seq Int) (seq.map (lambda ((l1_s0 (Seq Int))) - (let ((l1_s1 0)) - (let ((l1_s2 (seq.foldl (lambda ((l2_s0 Int) (l2_s1 Int)) - (+ l2_s0 l2_s1)) l1_s1 l1_s0))) - l1_s2))) s0)) -[GOOD] (define-fun s6 () Int (seq.foldl (lambda ((l1_s0 Int) (l1_s1 Int)) - (+ l1_s0 l1_s1)) s4 s5)) -[GOOD] (define-fun s7 () Bool (= s1 s6)) -[GOOD] ; --- delayedEqualities --- -[GOOD] ; --- formula --- -[GOOD] (assert s3) -[GOOD] (assert s7) -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s1)) -[RECV] ((s1 280)) -[SEND] (get-value (s0)) -[RECV] ((s0 (seq.++ (seq.unit (seq.++ (seq.unit 1) - (seq.unit 2) - (seq.unit 3) - (seq.unit 4) - (seq.unit 5))) - (seq.unit (seq.++ (seq.unit 1) - (seq.unit 2) - (seq.unit 3) - (seq.unit 4) - (seq.unit 5) - (seq.unit 6) - (seq.unit 7) - (seq.unit 8) - (seq.unit 9) - (seq.unit 10))) - (seq.unit (seq.++ (seq.unit 1) - (seq.unit 2) - (seq.unit 3) - (seq.unit 4) - (seq.unit 5) - (seq.unit 6) - (seq.unit 7) - (seq.unit 8) - (seq.unit 9) - (seq.unit 10) - (seq.unit 11) - (seq.unit 12) - (seq.unit 13) - (seq.unit 14) - (seq.unit 15) - (seq.unit 16) - (seq.unit 17) - (seq.unit 18) - (seq.unit 19) - (seq.unit 20)))))) -[SEND] (get-value (s1)) -[RECV] ((s1 280)) -*** Solver : Z3 -*** Exit code: ExitSuccess +CAUGHT EXCEPTION -RESULT: - s0 = [[1,2,3,4,5],[1,2,3,4,5,6,7,8,9,10],[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20]] :: [[Integer]] - s1 = 280 :: Integer + +*** Data.SBV.Lambda: Detected nested lambda-definitions. +*** +*** SBV uses firstification to deal-with lambdas, and SMTLib's first-order nature does not allow +*** for easy translation of nested lambdas. As SMTLib gets higher-order features, SBV will eventually +*** relax this restriction. In the mean-time, please rewrite your program without using nested-lambdas +*** if possible. If this workaround isn't applicable, please report this as a use-case for further +*** possible enhancements. diff --git a/SBVTestSuite/GoldFiles/lambda08.gold b/SBVTestSuite/GoldFiles/lambda08.gold --- a/SBVTestSuite/GoldFiles/lambda08.gold +++ b/SBVTestSuite/GoldFiles/lambda08.gold @@ -8,7 +8,7 @@ [GOOD] (set-option :pp.max_depth 4294967295) [GOOD] (set-option :pp.min_alias_size 4294967295) [GOOD] (set-option :model.inline_def true ) -[GOOD] (set-logic ALL) ; has lists, using catch-all. +[GOOD] (set-logic ALL) ; has lambda expressions, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums --- @@ -20,13 +20,20 @@ [GOOD] ; --- constant tables --- [GOOD] ; --- non-constant tables --- [GOOD] ; --- uninterpreted constants --- +[GOOD] ; --- Firstified function definitions +[GOOD] ; Firstified function: map :: (SFloat -> SFloat) -> [SFloat] -> [SFloat] +[GOOD] (define-fun-rec sbv.map_38e214 ((lst (Seq (_ FloatingPoint 8 24)))) (Seq (_ FloatingPoint 8 24)) + (ite (= lst (as seq.empty (Seq (_ FloatingPoint 8 24)))) + (as seq.empty (Seq (_ FloatingPoint 8 24))) + (seq.++ (seq.unit (select (lambda ((args0 (_ FloatingPoint 8 24))) + (let ((args1 ((_ to_fp 8 24) roundNearestTiesToEven (/ 1.0 1.0)))) + (let ((args2 (fp.add roundNearestTiesToEven args0 args1))) + args2))) (seq.nth lst 0))) + (sbv.map_38e214 (seq.extract lst 1 (- (seq.len lst) 1)))))) [GOOD] ; --- user defined functions --- [GOOD] ; --- assignments --- [GOOD] (define-fun s3 () Bool (= s0 s2)) -[GOOD] (define-fun s4 () (Seq (_ FloatingPoint 8 24)) (seq.map (lambda ((l1_s0 (_ FloatingPoint 8 24))) - (let ((l1_s1 ((_ to_fp 8 24) roundNearestTiesToEven (/ 1.0 1.0)))) - (let ((l1_s2 (fp.add roundNearestTiesToEven l1_s0 l1_s1))) - l1_s2))) s0)) +[GOOD] (define-fun s4 () (Seq (_ FloatingPoint 8 24)) (sbv.map_38e214 s0)) [GOOD] (define-fun s5 () Bool (= s1 s4)) [GOOD] ; --- delayedEqualities --- [GOOD] ; --- formula --- diff --git a/SBVTestSuite/GoldFiles/lambda09.gold b/SBVTestSuite/GoldFiles/lambda09.gold --- a/SBVTestSuite/GoldFiles/lambda09.gold +++ b/SBVTestSuite/GoldFiles/lambda09.gold @@ -8,7 +8,7 @@ [GOOD] (set-option :pp.max_depth 4294967295) [GOOD] (set-option :pp.min_alias_size 4294967295) [GOOD] (set-option :model.inline_def true ) -[GOOD] (set-logic ALL) ; has lists, using catch-all. +[GOOD] (set-logic ALL) ; has lambda expressions, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums --- @@ -20,13 +20,20 @@ [GOOD] ; --- constant tables --- [GOOD] ; --- non-constant tables --- [GOOD] ; --- uninterpreted constants --- +[GOOD] ; --- Firstified function definitions +[GOOD] ; Firstified function: map :: (SInt8 -> SInt8) -> [SInt8] -> [SInt8] +[GOOD] (define-fun-rec sbv.map_f0bd1d ((lst (Seq (_ BitVec 8)))) (Seq (_ BitVec 8)) + (ite (= lst (as seq.empty (Seq (_ BitVec 8)))) + (as seq.empty (Seq (_ BitVec 8))) + (seq.++ (seq.unit (select (lambda ((args0 (_ BitVec 8))) + (let ((args1 #x01)) + (let ((args2 (bvadd args0 args1))) + args2))) (seq.nth lst 0))) + (sbv.map_f0bd1d (seq.extract lst 1 (- (seq.len lst) 1)))))) [GOOD] ; --- user defined functions --- [GOOD] ; --- assignments --- [GOOD] (define-fun s3 () Bool (= s0 s2)) -[GOOD] (define-fun s4 () (Seq (_ BitVec 8)) (seq.map (lambda ((l1_s0 (_ BitVec 8))) - (let ((l1_s1 #x01)) - (let ((l1_s2 (bvadd l1_s0 l1_s1))) - l1_s2))) s0)) +[GOOD] (define-fun s4 () (Seq (_ BitVec 8)) (sbv.map_f0bd1d s0)) [GOOD] (define-fun s5 () Bool (= s1 s4)) [GOOD] ; --- delayedEqualities --- [GOOD] ; --- formula --- diff --git a/SBVTestSuite/GoldFiles/lambda10.gold b/SBVTestSuite/GoldFiles/lambda10.gold --- a/SBVTestSuite/GoldFiles/lambda10.gold +++ b/SBVTestSuite/GoldFiles/lambda10.gold @@ -8,7 +8,7 @@ [GOOD] (set-option :pp.max_depth 4294967295) [GOOD] (set-option :pp.min_alias_size 4294967295) [GOOD] (set-option :model.inline_def true ) -[GOOD] (set-logic ALL) ; has unbounded values, using catch-all. +[GOOD] (set-logic ALL) ; has lambda expressions, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums --- @@ -20,13 +20,20 @@ [GOOD] ; --- constant tables --- [GOOD] ; --- non-constant tables --- [GOOD] ; --- uninterpreted constants --- +[GOOD] ; --- Firstified function definitions +[GOOD] ; Firstified function: map :: (SInteger -> SInteger) -> [SInteger] -> [SInteger] +[GOOD] (define-fun-rec sbv.map_72c5bf ((lst (Seq Int))) (Seq Int) + (ite (= lst (as seq.empty (Seq Int))) + (as seq.empty (Seq Int)) + (seq.++ (seq.unit (select (lambda ((args0 Int)) + (let ((args1 1)) + (let ((args2 (+ args0 args1))) + args2))) (seq.nth lst 0))) + (sbv.map_72c5bf (seq.extract lst 1 (- (seq.len lst) 1)))))) [GOOD] ; --- user defined functions --- [GOOD] ; --- assignments --- [GOOD] (define-fun s3 () Bool (= s0 s2)) -[GOOD] (define-fun s4 () (Seq Int) (seq.map (lambda ((l1_s0 Int)) - (let ((l1_s1 1)) - (let ((l1_s2 (+ l1_s0 l1_s1))) - l1_s2))) s0)) +[GOOD] (define-fun s4 () (Seq Int) (sbv.map_72c5bf s0)) [GOOD] (define-fun s5 () Bool (= s1 s4)) [GOOD] ; --- delayedEqualities --- [GOOD] ; --- formula --- diff --git a/SBVTestSuite/GoldFiles/lambda11.gold b/SBVTestSuite/GoldFiles/lambda11.gold --- a/SBVTestSuite/GoldFiles/lambda11.gold +++ b/SBVTestSuite/GoldFiles/lambda11.gold @@ -8,7 +8,7 @@ [GOOD] (set-option :pp.max_depth 4294967295) [GOOD] (set-option :pp.min_alias_size 4294967295) [GOOD] (set-option :model.inline_def true ) -[GOOD] (set-logic ALL) ; has lists, using catch-all. +[GOOD] (set-logic ALL) ; has lambda expressions, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums --- @@ -20,13 +20,20 @@ [GOOD] ; --- constant tables --- [GOOD] ; --- non-constant tables --- [GOOD] ; --- uninterpreted constants --- +[GOOD] ; --- Firstified function definitions +[GOOD] ; Firstified function: map :: (SWord8 -> SWord8) -> [SWord8] -> [SWord8] +[GOOD] (define-fun-rec sbv.map_1a14e2 ((lst (Seq (_ BitVec 8)))) (Seq (_ BitVec 8)) + (ite (= lst (as seq.empty (Seq (_ BitVec 8)))) + (as seq.empty (Seq (_ BitVec 8))) + (seq.++ (seq.unit (select (lambda ((args0 (_ BitVec 8))) + (let ((args1 #x01)) + (let ((args2 (bvadd args0 args1))) + args2))) (seq.nth lst 0))) + (sbv.map_1a14e2 (seq.extract lst 1 (- (seq.len lst) 1)))))) [GOOD] ; --- user defined functions --- [GOOD] ; --- assignments --- [GOOD] (define-fun s3 () Bool (= s0 s2)) -[GOOD] (define-fun s4 () (Seq (_ BitVec 8)) (seq.map (lambda ((l1_s0 (_ BitVec 8))) - (let ((l1_s1 #x01)) - (let ((l1_s2 (bvadd l1_s0 l1_s1))) - l1_s2))) s0)) +[GOOD] (define-fun s4 () (Seq (_ BitVec 8)) (sbv.map_1a14e2 s0)) [GOOD] (define-fun s5 () Bool (= s1 s4)) [GOOD] ; --- delayedEqualities --- [GOOD] ; --- formula --- diff --git a/SBVTestSuite/GoldFiles/lambda12.gold b/SBVTestSuite/GoldFiles/lambda12.gold --- a/SBVTestSuite/GoldFiles/lambda12.gold +++ b/SBVTestSuite/GoldFiles/lambda12.gold @@ -8,7 +8,7 @@ [GOOD] (set-option :pp.max_depth 4294967295) [GOOD] (set-option :pp.min_alias_size 4294967295) [GOOD] (set-option :model.inline_def true ) -[GOOD] (set-logic ALL) ; has unbounded values, using catch-all. +[GOOD] (set-logic ALL) ; has lambda expressions, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums --- @@ -20,11 +20,18 @@ [GOOD] ; --- constant tables --- [GOOD] ; --- non-constant tables --- [GOOD] ; --- uninterpreted constants --- +[GOOD] ; --- Firstified function definitions +[GOOD] ; Firstified function: map :: (SInteger -> [SInteger]) -> [SInteger] -> [[SInteger]] +[GOOD] (define-fun-rec sbv.map_0004cc ((lst (Seq Int))) (Seq (Seq Int)) + (ite (= lst (as seq.empty (Seq Int))) + (as seq.empty (Seq (Seq Int))) + (seq.++ (seq.unit (select (lambda ((args0 Int)) + (seq.unit args0)) (seq.nth lst 0))) + (sbv.map_0004cc (seq.extract lst 1 (- (seq.len lst) 1)))))) [GOOD] ; --- user defined functions --- [GOOD] ; --- assignments --- [GOOD] (define-fun s3 () Bool (= s0 s2)) -[GOOD] (define-fun s4 () (Seq (Seq Int)) (seq.map (lambda ((l1_s0 Int)) - (seq.unit l1_s0)) s0)) +[GOOD] (define-fun s4 () (Seq (Seq Int)) (sbv.map_0004cc s0)) [GOOD] (define-fun s5 () Bool (= s1 s4)) [GOOD] ; --- delayedEqualities --- [GOOD] ; --- formula --- diff --git a/SBVTestSuite/GoldFiles/lambda13.gold b/SBVTestSuite/GoldFiles/lambda13.gold --- a/SBVTestSuite/GoldFiles/lambda13.gold +++ b/SBVTestSuite/GoldFiles/lambda13.gold @@ -8,7 +8,7 @@ [GOOD] (set-option :pp.max_depth 4294967295) [GOOD] (set-option :pp.min_alias_size 4294967295) [GOOD] (set-option :model.inline_def true ) -[GOOD] (set-logic ALL) ; has unbounded values, using catch-all. +[GOOD] (set-logic ALL) ; has lambda expressions, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] (declare-datatypes ((SBVTuple2 2)) ((par (T1 T2) @@ -23,14 +23,21 @@ [GOOD] ; --- constant tables --- [GOOD] ; --- non-constant tables --- [GOOD] ; --- uninterpreted constants --- +[GOOD] ; --- Firstified function definitions +[GOOD] ; Firstified function: map :: ((SInteger, SInteger) -> SInteger) -> [(SInteger, SInteger)] -> [SInteger] +[GOOD] (define-fun-rec sbv.map_cb21ff ((lst (Seq (SBVTuple2 Int Int)))) (Seq Int) + (ite (= lst (as seq.empty (Seq (SBVTuple2 Int Int)))) + (as seq.empty (Seq Int)) + (seq.++ (seq.unit (select (lambda ((args0 (SBVTuple2 Int Int))) + (let ((args1 (proj_1_SBVTuple2 args0))) + (let ((args2 (proj_2_SBVTuple2 args0))) + (let ((args3 (+ args1 args2))) + args3)))) (seq.nth lst 0))) + (sbv.map_cb21ff (seq.extract lst 1 (- (seq.len lst) 1)))))) [GOOD] ; --- user defined functions --- [GOOD] ; --- assignments --- [GOOD] (define-fun s3 () Bool (= s0 s2)) -[GOOD] (define-fun s4 () (Seq Int) (seq.map (lambda ((l1_s0 (SBVTuple2 Int Int))) - (let ((l1_s1 (proj_1_SBVTuple2 l1_s0))) - (let ((l1_s2 (proj_2_SBVTuple2 l1_s0))) - (let ((l1_s3 (+ l1_s1 l1_s2))) - l1_s3)))) s0)) +[GOOD] (define-fun s4 () (Seq Int) (sbv.map_cb21ff s0)) [GOOD] (define-fun s5 () Bool (= s1 s4)) [GOOD] ; --- delayedEqualities --- [GOOD] ; --- formula --- diff --git a/SBVTestSuite/GoldFiles/lambda14.gold b/SBVTestSuite/GoldFiles/lambda14.gold --- a/SBVTestSuite/GoldFiles/lambda14.gold +++ b/SBVTestSuite/GoldFiles/lambda14.gold @@ -8,24 +8,30 @@ [GOOD] (set-option :pp.max_depth 4294967295) [GOOD] (set-option :pp.min_alias_size 4294967295) [GOOD] (set-option :model.inline_def true ) -[GOOD] (set-logic ALL) ; has unbounded values, using catch-all. +[GOOD] (set-logic ALL) ; has lambda expressions, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums --- [GOOD] ; --- literal constants --- [GOOD] (define-fun s2 () (Seq Int) (seq.++ (seq.unit 1) (seq.unit 2) (seq.unit 3) (seq.unit 4) (seq.unit 5))) -[GOOD] (define-fun s4 () Int 10) +[GOOD] (define-fun s4 () (Seq Int) (seq.++ (seq.unit 10) (seq.unit 11) (seq.unit 12) (seq.unit 13) (seq.unit 14) (seq.unit 15))) [GOOD] ; --- top level inputs --- [GOOD] (declare-fun s0 () (Seq Int)) [GOOD] (declare-fun s1 () (Seq Int)) [GOOD] ; --- constant tables --- [GOOD] ; --- non-constant tables --- [GOOD] ; --- uninterpreted constants --- +[GOOD] ; --- Firstified function definitions +[GOOD] ; Firstified function: zipWith :: (SInteger -> SInteger -> SInteger) -> [SInteger] -> [SInteger] -> [SInteger] +[GOOD] (define-fun-rec sbv.zipWith_736833 ((lst1 (Seq Int)) (lst2 (Seq Int))) (Seq Int) + (ite (or (= lst1 (as seq.empty (Seq Int))) (= lst2 (as seq.empty (Seq Int)))) + (as seq.empty (Seq Int)) + (seq.++ (seq.unit (select (lambda ((args0 Int) (args1 Int)) + (+ args0 args1)) (seq.nth lst1 0) (seq.nth lst2 0))) (sbv.zipWith_736833 (seq.extract lst1 1 (- (seq.len lst1) 1)) (seq.extract lst2 1 (- (seq.len lst2) 1)))))) [GOOD] ; --- user defined functions --- [GOOD] ; --- assignments --- [GOOD] (define-fun s3 () Bool (= s0 s2)) -[GOOD] (define-fun s5 () (Seq Int) (seq.mapi (lambda ((l1_s0 Int) (l1_s1 Int)) - (+ l1_s0 l1_s1)) s4 s0)) +[GOOD] (define-fun s5 () (Seq Int) (sbv.zipWith_736833 s4 s0)) [GOOD] (define-fun s6 () Bool (= s1 s5)) [GOOD] ; --- delayedEqualities --- [GOOD] ; --- formula --- diff --git a/SBVTestSuite/GoldFiles/lambda15.gold b/SBVTestSuite/GoldFiles/lambda15.gold --- a/SBVTestSuite/GoldFiles/lambda15.gold +++ b/SBVTestSuite/GoldFiles/lambda15.gold @@ -8,7 +8,7 @@ [GOOD] (set-option :pp.max_depth 4294967295) [GOOD] (set-option :pp.min_alias_size 4294967295) [GOOD] (set-option :model.inline_def true ) -[GOOD] (set-logic ALL) ; has unbounded values, using catch-all. +[GOOD] (set-logic ALL) ; has lambda expressions, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums --- @@ -21,11 +21,17 @@ [GOOD] ; --- constant tables --- [GOOD] ; --- non-constant tables --- [GOOD] ; --- uninterpreted constants --- +[GOOD] ; --- Firstified function definitions +[GOOD] ; Firstified function: foldl :: (SInteger -> SInteger -> SInteger) -> SInteger -> [SInteger] -> SInteger +[GOOD] (define-fun-rec sbv.foldl_a12137 ((base Int) (lst (Seq Int))) Int + (ite (= lst (as seq.empty (Seq Int))) + base + (sbv.foldl_a12137 (select (lambda ((args0 Int) (args1 Int)) + (+ args0 args1)) base (seq.nth lst 0)) (seq.extract lst 1 (- (seq.len lst) 1))))) [GOOD] ; --- user defined functions --- [GOOD] ; --- assignments --- [GOOD] (define-fun s3 () Bool (= s0 s2)) -[GOOD] (define-fun s5 () Int (seq.foldl (lambda ((l1_s0 Int) (l1_s1 Int)) - (+ l1_s0 l1_s1)) s4 s0)) +[GOOD] (define-fun s5 () Int (sbv.foldl_a12137 s4 s0)) [GOOD] (define-fun s6 () Bool (= s1 s5)) [GOOD] ; --- delayedEqualities --- [GOOD] ; --- formula --- diff --git a/SBVTestSuite/GoldFiles/lambda16.gold b/SBVTestSuite/GoldFiles/lambda16.gold --- a/SBVTestSuite/GoldFiles/lambda16.gold +++ b/SBVTestSuite/GoldFiles/lambda16.gold @@ -8,7 +8,7 @@ [GOOD] (set-option :pp.max_depth 4294967295) [GOOD] (set-option :pp.min_alias_size 4294967295) [GOOD] (set-option :model.inline_def true ) -[GOOD] (set-logic ALL) ; has unbounded values, using catch-all. +[GOOD] (set-logic ALL) ; has lambda expressions, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums --- @@ -21,11 +21,17 @@ [GOOD] ; --- constant tables --- [GOOD] ; --- non-constant tables --- [GOOD] ; --- uninterpreted constants --- +[GOOD] ; --- Firstified function definitions +[GOOD] ; Firstified function: foldl :: (SInteger -> SInteger -> SInteger) -> SInteger -> [SInteger] -> SInteger +[GOOD] (define-fun-rec sbv.foldl_33c9b2 ((base Int) (lst (Seq Int))) Int + (ite (= lst (as seq.empty (Seq Int))) + base + (sbv.foldl_33c9b2 (select (lambda ((args0 Int) (args1 Int)) + (* args0 args1)) base (seq.nth lst 0)) (seq.extract lst 1 (- (seq.len lst) 1))))) [GOOD] ; --- user defined functions --- [GOOD] ; --- assignments --- [GOOD] (define-fun s3 () Bool (= s0 s2)) -[GOOD] (define-fun s5 () Int (seq.foldl (lambda ((l1_s0 Int) (l1_s1 Int)) - (* l1_s0 l1_s1)) s4 s0)) +[GOOD] (define-fun s5 () Int (sbv.foldl_33c9b2 s4 s0)) [GOOD] (define-fun s6 () Bool (= s1 s5)) [GOOD] ; --- delayedEqualities --- [GOOD] ; --- formula --- diff --git a/SBVTestSuite/GoldFiles/lambda17.gold b/SBVTestSuite/GoldFiles/lambda17.gold --- a/SBVTestSuite/GoldFiles/lambda17.gold +++ b/SBVTestSuite/GoldFiles/lambda17.gold @@ -8,7 +8,7 @@ [GOOD] (set-option :pp.max_depth 4294967295) [GOOD] (set-option :pp.min_alias_size 4294967295) [GOOD] (set-option :model.inline_def true ) -[GOOD] (set-logic ALL) ; has unbounded values, using catch-all. +[GOOD] (set-logic ALL) ; has lambda expressions, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums --- @@ -21,13 +21,19 @@ [GOOD] ; --- constant tables --- [GOOD] ; --- non-constant tables --- [GOOD] ; --- uninterpreted constants --- +[GOOD] ; --- Firstified function definitions +[GOOD] ; Firstified function: foldl :: ([SInteger] -> SInteger -> [SInteger]) -> [SInteger] -> [SInteger] -> [SInteger] +[GOOD] (define-fun-rec sbv.foldl_c4d425 ((base (Seq Int)) (lst (Seq Int))) (Seq Int) + (ite (= lst (as seq.empty (Seq Int))) + base + (sbv.foldl_c4d425 (select (lambda ((args0 (Seq Int)) (args1 Int)) + (let ((args2 (seq.unit args1))) + (let ((args3 (seq.++ args2 args0))) + args3))) base (seq.nth lst 0)) (seq.extract lst 1 (- (seq.len lst) 1))))) [GOOD] ; --- user defined functions --- [GOOD] ; --- assignments --- [GOOD] (define-fun s3 () Bool (= s0 s2)) -[GOOD] (define-fun s5 () (Seq Int) (seq.foldl (lambda ((l1_s0 (Seq Int)) (l1_s1 Int)) - (let ((l1_s2 (seq.unit l1_s1))) - (let ((l1_s3 (seq.++ l1_s2 l1_s0))) - l1_s3))) s4 s0)) +[GOOD] (define-fun s5 () (Seq Int) (sbv.foldl_c4d425 s4 s0)) [GOOD] (define-fun s6 () Bool (= s1 s5)) [GOOD] ; --- delayedEqualities --- [GOOD] ; --- formula --- diff --git a/SBVTestSuite/GoldFiles/lambda18.gold b/SBVTestSuite/GoldFiles/lambda18.gold --- a/SBVTestSuite/GoldFiles/lambda18.gold +++ b/SBVTestSuite/GoldFiles/lambda18.gold @@ -8,32 +8,49 @@ [GOOD] (set-option :pp.max_depth 4294967295) [GOOD] (set-option :pp.min_alias_size 4294967295) [GOOD] (set-option :model.inline_def true ) -[GOOD] (set-logic ALL) ; has unbounded values, using catch-all. +[GOOD] (set-logic ALL) ; has lambda expressions, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- +[GOOD] (declare-datatypes ((SBVTuple2 2)) ((par (T1 T2) + ((mkSBVTuple2 (proj_1_SBVTuple2 T1) + (proj_2_SBVTuple2 T2)))))) [GOOD] ; --- sums --- [GOOD] ; --- literal constants --- [GOOD] (define-fun s2 () (Seq Int) (seq.++ (seq.unit 1) (seq.unit 2) (seq.unit 3) (seq.unit 4) (seq.unit 5))) -[GOOD] (define-fun s4 () Int 10) -[GOOD] (define-fun s5 () Int 0) +[GOOD] (define-fun s4 () Int 0) +[GOOD] (define-fun s5 () (Seq Int) (seq.++ (seq.unit 10) (seq.unit 11) (seq.unit 12) (seq.unit 13) (seq.unit 14) (seq.unit 15))) [GOOD] ; --- top level inputs --- [GOOD] (declare-fun s0 () (Seq Int)) [GOOD] (declare-fun s1 () Int) [GOOD] ; --- constant tables --- [GOOD] ; --- non-constant tables --- [GOOD] ; --- uninterpreted constants --- +[GOOD] ; --- Firstified function definitions +[GOOD] ; Firstified function: zip :: [SInteger] -> [SInteger] -> [(SInteger, SInteger)] +[GOOD] (define-fun-rec sbv.zip_88576a ((lst1 (Seq Int)) (lst2 (Seq Int))) (Seq (SBVTuple2 Int Int)) + (ite (or (= lst1 (as seq.empty (Seq Int))) (= lst2 (as seq.empty (Seq Int)))) + (as seq.empty (Seq (SBVTuple2 Int Int))) + (seq.++ (seq.unit ((as mkSBVTuple2 (SBVTuple2 Int Int)) (seq.nth lst1 0) (seq.nth lst2 0))) (sbv.zip_88576a (seq.extract lst1 1 (- (seq.len lst1) 1)) (seq.extract lst2 1 (- (seq.len lst2) 1)))))) +[GOOD] ; Firstified function: foldl :: (SInteger -> (SInteger, SInteger) -> SInteger) -> SInteger -> [(SInteger, SInteger)] -> SInteger +[GOOD] (define-fun-rec sbv.foldl_7f1bfe ((base Int) (lst (Seq (SBVTuple2 Int Int)))) Int + (ite (= lst (as seq.empty (Seq (SBVTuple2 Int Int)))) + base + (sbv.foldl_7f1bfe (select (lambda ((args0 Int) (args1 (SBVTuple2 Int Int))) + (let ((args2 (proj_1_SBVTuple2 args1))) + (let ((args3 (+ args0 args2))) + (let ((args4 (proj_2_SBVTuple2 args1))) + (let ((args5 (+ args3 args4))) + args5))))) base (seq.nth lst 0)) (seq.extract lst 1 (- (seq.len lst) 1))))) [GOOD] ; --- user defined functions --- [GOOD] ; --- assignments --- [GOOD] (define-fun s3 () Bool (= s0 s2)) -[GOOD] (define-fun s6 () Int (seq.foldli (lambda ((l1_s0 Int) (l1_s1 Int) (l1_s2 Int)) - (let ((l1_s3 (+ l1_s0 l1_s1))) - (let ((l1_s4 (+ l1_s2 l1_s3))) - l1_s4))) s4 s5 s0)) -[GOOD] (define-fun s7 () Bool (= s1 s6)) +[GOOD] (define-fun s6 () (Seq (SBVTuple2 Int Int)) (sbv.zip_88576a s5 s0)) +[GOOD] (define-fun s7 () Int (sbv.foldl_7f1bfe s4 s6)) +[GOOD] (define-fun s8 () Bool (= s1 s7)) [GOOD] ; --- delayedEqualities --- [GOOD] ; --- formula --- [GOOD] (assert s3) -[GOOD] (assert s7) +[GOOD] (assert s8) [SEND] (check-sat) [RECV] sat [SEND] (get-value (s1)) diff --git a/SBVTestSuite/GoldFiles/lambda19.gold b/SBVTestSuite/GoldFiles/lambda19.gold --- a/SBVTestSuite/GoldFiles/lambda19.gold +++ b/SBVTestSuite/GoldFiles/lambda19.gold @@ -8,7 +8,7 @@ [GOOD] (set-option :pp.max_depth 4294967295) [GOOD] (set-option :pp.min_alias_size 4294967295) [GOOD] (set-option :model.inline_def true ) -[GOOD] (set-logic ALL) ; has unbounded values, using catch-all. +[GOOD] (set-logic ALL) ; has lambda expressions, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums --- @@ -21,22 +21,22 @@ [GOOD] ; --- constant tables --- [GOOD] ; --- non-constant tables --- [GOOD] ; --- uninterpreted constants --- -[GOOD] ; --- SBV Function definitions -[GOOD] (define-fun-rec |sbv.reverse_[SInteger]| ((lst (Seq Int))) (Seq Int) +[GOOD] ; --- Firstified function definitions +[GOOD] ; Firstified function: foldr :: (SInteger -> SInteger -> SInteger) -> SInteger -> [SInteger] -> SInteger +[GOOD] (define-fun-rec sbv.foldr_5cb25c ((base Int) (lst (Seq Int))) Int (ite (= lst (as seq.empty (Seq Int))) - (as seq.empty (Seq Int)) - (seq.++ (|sbv.reverse_[SInteger]| (seq.extract lst 1 (- (seq.len lst) 1))) (seq.unit (seq.nth lst 0))))) + base + (select (lambda ((args0 Int) (args1 Int)) + (+ args0 args1)) (seq.nth lst 0) (sbv.foldr_5cb25c base (seq.extract lst 1 (- (seq.len lst) 1)))))) [GOOD] ; --- user defined functions --- [GOOD] ; --- assignments --- [GOOD] (define-fun s3 () Bool (= s0 s2)) -[GOOD] (define-fun s5 () (Seq Int) (|sbv.reverse_[SInteger]| s0)) -[GOOD] (define-fun s6 () Int (seq.foldl (lambda ((l1_s0 Int) (l1_s1 Int)) - (+ l1_s0 l1_s1)) s4 s5)) -[GOOD] (define-fun s7 () Bool (= s1 s6)) +[GOOD] (define-fun s5 () Int (sbv.foldr_5cb25c s4 s0)) +[GOOD] (define-fun s6 () Bool (= s1 s5)) [GOOD] ; --- delayedEqualities --- [GOOD] ; --- formula --- [GOOD] (assert s3) -[GOOD] (assert s7) +[GOOD] (assert s6) [SEND] (check-sat) [RECV] sat [SEND] (get-value (s1)) diff --git a/SBVTestSuite/GoldFiles/lambda20.gold b/SBVTestSuite/GoldFiles/lambda20.gold --- a/SBVTestSuite/GoldFiles/lambda20.gold +++ b/SBVTestSuite/GoldFiles/lambda20.gold @@ -8,7 +8,7 @@ [GOOD] (set-option :pp.max_depth 4294967295) [GOOD] (set-option :pp.min_alias_size 4294967295) [GOOD] (set-option :model.inline_def true ) -[GOOD] (set-logic ALL) ; has unbounded values, using catch-all. +[GOOD] (set-logic ALL) ; has lambda expressions, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums --- @@ -21,22 +21,22 @@ [GOOD] ; --- constant tables --- [GOOD] ; --- non-constant tables --- [GOOD] ; --- uninterpreted constants --- -[GOOD] ; --- SBV Function definitions -[GOOD] (define-fun-rec |sbv.reverse_[SInteger]| ((lst (Seq Int))) (Seq Int) +[GOOD] ; --- Firstified function definitions +[GOOD] ; Firstified function: foldr :: (SInteger -> SInteger -> SInteger) -> SInteger -> [SInteger] -> SInteger +[GOOD] (define-fun-rec sbv.foldr_e5d95a ((base Int) (lst (Seq Int))) Int (ite (= lst (as seq.empty (Seq Int))) - (as seq.empty (Seq Int)) - (seq.++ (|sbv.reverse_[SInteger]| (seq.extract lst 1 (- (seq.len lst) 1))) (seq.unit (seq.nth lst 0))))) + base + (select (lambda ((args0 Int) (args1 Int)) + (* args0 args1)) (seq.nth lst 0) (sbv.foldr_e5d95a base (seq.extract lst 1 (- (seq.len lst) 1)))))) [GOOD] ; --- user defined functions --- [GOOD] ; --- assignments --- [GOOD] (define-fun s3 () Bool (= s0 s2)) -[GOOD] (define-fun s5 () (Seq Int) (|sbv.reverse_[SInteger]| s0)) -[GOOD] (define-fun s6 () Int (seq.foldl (lambda ((l1_s0 Int) (l1_s1 Int)) - (* l1_s0 l1_s1)) s4 s5)) -[GOOD] (define-fun s7 () Bool (= s1 s6)) +[GOOD] (define-fun s5 () Int (sbv.foldr_e5d95a s4 s0)) +[GOOD] (define-fun s6 () Bool (= s1 s5)) [GOOD] ; --- delayedEqualities --- [GOOD] ; --- formula --- [GOOD] (assert s3) -[GOOD] (assert s7) +[GOOD] (assert s6) [SEND] (check-sat) [RECV] sat [SEND] (get-value (s1)) diff --git a/SBVTestSuite/GoldFiles/lambda21.gold b/SBVTestSuite/GoldFiles/lambda21.gold --- a/SBVTestSuite/GoldFiles/lambda21.gold +++ b/SBVTestSuite/GoldFiles/lambda21.gold @@ -8,7 +8,7 @@ [GOOD] (set-option :pp.max_depth 4294967295) [GOOD] (set-option :pp.min_alias_size 4294967295) [GOOD] (set-option :model.inline_def true ) -[GOOD] (set-logic ALL) ; has unbounded values, using catch-all. +[GOOD] (set-logic ALL) ; has lambda expressions, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums --- @@ -21,24 +21,24 @@ [GOOD] ; --- constant tables --- [GOOD] ; --- non-constant tables --- [GOOD] ; --- uninterpreted constants --- -[GOOD] ; --- SBV Function definitions -[GOOD] (define-fun-rec |sbv.reverse_[SInteger]| ((lst (Seq Int))) (Seq Int) +[GOOD] ; --- Firstified function definitions +[GOOD] ; Firstified function: foldr :: (SInteger -> [SInteger] -> [SInteger]) -> [SInteger] -> [SInteger] -> [SInteger] +[GOOD] (define-fun-rec sbv.foldr_3ea6b3 ((base (Seq Int)) (lst (Seq Int))) (Seq Int) (ite (= lst (as seq.empty (Seq Int))) - (as seq.empty (Seq Int)) - (seq.++ (|sbv.reverse_[SInteger]| (seq.extract lst 1 (- (seq.len lst) 1))) (seq.unit (seq.nth lst 0))))) + base + (select (lambda ((args0 Int) (args1 (Seq Int))) + (let ((args2 (seq.unit args0))) + (let ((args3 (seq.++ args1 args2))) + args3))) (seq.nth lst 0) (sbv.foldr_3ea6b3 base (seq.extract lst 1 (- (seq.len lst) 1)))))) [GOOD] ; --- user defined functions --- [GOOD] ; --- assignments --- [GOOD] (define-fun s3 () Bool (= s0 s2)) -[GOOD] (define-fun s5 () (Seq Int) (|sbv.reverse_[SInteger]| s0)) -[GOOD] (define-fun s6 () (Seq Int) (seq.foldl (lambda ((l1_s0 (Seq Int)) (l1_s1 Int)) - (let ((l1_s2 (seq.unit l1_s1))) - (let ((l1_s3 (seq.++ l1_s0 l1_s2))) - l1_s3))) s4 s5)) -[GOOD] (define-fun s7 () Bool (= s1 s6)) +[GOOD] (define-fun s5 () (Seq Int) (sbv.foldr_3ea6b3 s4 s0)) +[GOOD] (define-fun s6 () Bool (= s1 s5)) [GOOD] ; --- delayedEqualities --- [GOOD] ; --- formula --- [GOOD] (assert s3) -[GOOD] (assert s7) +[GOOD] (assert s6) [SEND] (check-sat) [RECV] sat [SEND] (get-value (s1)) diff --git a/SBVTestSuite/GoldFiles/lambda22.gold b/SBVTestSuite/GoldFiles/lambda22.gold --- a/SBVTestSuite/GoldFiles/lambda22.gold +++ b/SBVTestSuite/GoldFiles/lambda22.gold @@ -18,8 +18,6 @@ [GOOD] ; --- literal constants --- [GOOD] (define-fun s3 () (Seq Int) (seq.++ (seq.unit 1) (seq.unit 2) (seq.unit 3) (seq.unit 4) (seq.unit 5) (seq.unit 6) (seq.unit 7) (seq.unit 8) (seq.unit 9) (seq.unit 10))) [GOOD] (define-fun s5 () (Seq Int) (seq.++ (seq.unit 11) (seq.unit 12) (seq.unit 13) (seq.unit 14) (seq.unit 15) (seq.unit 16) (seq.unit 17) (seq.unit 18) (seq.unit 19) (seq.unit 20))) -[GOOD] (define-fun s7 () Int 0) -[GOOD] (define-fun s10 () (Seq Int) (as seq.empty (Seq Int))) [GOOD] ; --- top level inputs --- [GOOD] (declare-fun s0 () (Seq Int)) [GOOD] (declare-fun s1 () (Seq Int)) @@ -27,31 +25,23 @@ [GOOD] ; --- constant tables --- [GOOD] ; --- non-constant tables --- [GOOD] ; --- uninterpreted constants --- +[GOOD] ; --- Firstified function definitions +[GOOD] ; Firstified function: zip :: [SInteger] -> [SInteger] -> [(SInteger, SInteger)] +[GOOD] (define-fun-rec sbv.zip_88576a ((lst1 (Seq Int)) (lst2 (Seq Int))) (Seq (SBVTuple2 Int Int)) + (ite (or (= lst1 (as seq.empty (Seq Int))) (= lst2 (as seq.empty (Seq Int)))) + (as seq.empty (Seq (SBVTuple2 Int Int))) + (seq.++ (seq.unit ((as mkSBVTuple2 (SBVTuple2 Int Int)) (seq.nth lst1 0) (seq.nth lst2 0))) (sbv.zip_88576a (seq.extract lst1 1 (- (seq.len lst1) 1)) (seq.extract lst2 1 (- (seq.len lst2) 1)))))) [GOOD] ; --- user defined functions --- [GOOD] ; --- assignments --- [GOOD] (define-fun s4 () Bool (= s0 s3)) [GOOD] (define-fun s6 () Bool (= s1 s5)) -[GOOD] (define-fun s8 () Int (seq.len s1)) -[GOOD] (define-fun s9 () Bool (<= s8 s7)) -[GOOD] (define-fun s11 () Int (seq.len s0)) -[GOOD] (define-fun s12 () Bool (>= s8 s11)) -[GOOD] (define-fun s13 () (Seq Int) (seq.extract s0 s7 s8)) -[GOOD] (define-fun s14 () (Seq Int) (ite s12 s0 s13)) -[GOOD] (define-fun s15 () (Seq Int) (ite s9 s10 s14)) -[GOOD] (define-fun s16 () (Seq (SBVTuple2 Int Int)) (seq.mapi (lambda ((l1_s0 Int) (l1_s1 Int)) - ((as mkSBVTuple2 (SBVTuple2 Int Int)) l1_s0 l1_s1)) s7 s15)) -[GOOD] (define-fun s17 () (Seq (SBVTuple2 Int Int)) (seq.map (lambda ((l1_s0 (SBVTuple2 Int Int))) - (let ((l1_s1 (proj_2_SBVTuple2 l1_s0))) - (let ((l1_s2 (proj_1_SBVTuple2 l1_s0))) - (let ((l1_s3 (seq.nth s1 l1_s2))) - (let ((l1_s4 ((as mkSBVTuple2 (SBVTuple2 Int Int)) l1_s1 l1_s3))) - l1_s4))))) s16)) -[GOOD] (define-fun s18 () Bool (= s2 s17)) +[GOOD] (define-fun s7 () (Seq (SBVTuple2 Int Int)) (sbv.zip_88576a s0 s1)) +[GOOD] (define-fun s8 () Bool (= s2 s7)) [GOOD] ; --- delayedEqualities --- [GOOD] ; --- formula --- [GOOD] (assert s4) [GOOD] (assert s6) -[GOOD] (assert s18) +[GOOD] (assert s8) [SEND] (check-sat) [RECV] sat [SEND] (get-value (s2)) diff --git a/SBVTestSuite/GoldFiles/lambda23.gold b/SBVTestSuite/GoldFiles/lambda23.gold --- a/SBVTestSuite/GoldFiles/lambda23.gold +++ b/SBVTestSuite/GoldFiles/lambda23.gold @@ -8,7 +8,7 @@ [GOOD] (set-option :pp.max_depth 4294967295) [GOOD] (set-option :pp.min_alias_size 4294967295) [GOOD] (set-option :model.inline_def true ) -[GOOD] (set-logic ALL) ; has unbounded values, using catch-all. +[GOOD] (set-logic ALL) ; has lambda expressions, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] (declare-datatypes ((SBVTuple2 2)) ((par (T1 T2) @@ -19,7 +19,6 @@ [GOOD] (define-fun s3 () (Seq Int) (seq.++ (seq.unit 1) (seq.unit 2) (seq.unit 3) (seq.unit 4) (seq.unit 5) (seq.unit 6) (seq.unit 7) (seq.unit 8) (seq.unit 9) (seq.unit 10))) [GOOD] (define-fun s5 () (Seq Int) (seq.++ (seq.unit 10) (seq.unit 9) (seq.unit 8) (seq.unit 7) (seq.unit 6) (seq.unit 5) (seq.unit 4) (seq.unit 3) (seq.unit 2) (seq.unit 1))) [GOOD] (define-fun s7 () Int 0) -[GOOD] (define-fun s10 () (Seq Int) (as seq.empty (Seq Int))) [GOOD] ; --- top level inputs --- [GOOD] (declare-fun s0 () (Seq Int)) [GOOD] (declare-fun s1 () (Seq Int)) @@ -27,44 +26,41 @@ [GOOD] ; --- constant tables --- [GOOD] ; --- non-constant tables --- [GOOD] ; --- uninterpreted constants --- -[GOOD] ; --- SBV Function definitions -[GOOD] (define-fun-rec |sbv.reverse_[SInteger]| ((lst (Seq Int))) (Seq Int) +[GOOD] ; --- Firstified function definitions +[GOOD] ; Firstified function: zip :: [SInteger] -> [SInteger] -> [(SInteger, SInteger)] +[GOOD] (define-fun-rec sbv.zip_88576a ((lst1 (Seq Int)) (lst2 (Seq Int))) (Seq (SBVTuple2 Int Int)) + (ite (or (= lst1 (as seq.empty (Seq Int))) (= lst2 (as seq.empty (Seq Int)))) + (as seq.empty (Seq (SBVTuple2 Int Int))) + (seq.++ (seq.unit ((as mkSBVTuple2 (SBVTuple2 Int Int)) (seq.nth lst1 0) (seq.nth lst2 0))) (sbv.zip_88576a (seq.extract lst1 1 (- (seq.len lst1) 1)) (seq.extract lst2 1 (- (seq.len lst2) 1)))))) +[GOOD] ; Firstified function: map :: ((SInteger, SInteger) -> SInteger) -> [(SInteger, SInteger)] -> [SInteger] +[GOOD] (define-fun-rec sbv.map_cb21ff ((lst (Seq (SBVTuple2 Int Int)))) (Seq Int) + (ite (= lst (as seq.empty (Seq (SBVTuple2 Int Int)))) + (as seq.empty (Seq Int)) + (seq.++ (seq.unit (select (lambda ((args0 (SBVTuple2 Int Int))) + (let ((args1 (proj_1_SBVTuple2 args0))) + (let ((args2 (proj_2_SBVTuple2 args0))) + (let ((args3 (+ args1 args2))) + args3)))) (seq.nth lst 0))) + (sbv.map_cb21ff (seq.extract lst 1 (- (seq.len lst) 1)))))) +[GOOD] ; Firstified function: foldr :: (SInteger -> SInteger -> SInteger) -> SInteger -> [SInteger] -> SInteger +[GOOD] (define-fun-rec sbv.foldr_5cb25c ((base Int) (lst (Seq Int))) Int (ite (= lst (as seq.empty (Seq Int))) - (as seq.empty (Seq Int)) - (seq.++ (|sbv.reverse_[SInteger]| (seq.extract lst 1 (- (seq.len lst) 1))) (seq.unit (seq.nth lst 0))))) + base + (select (lambda ((args0 Int) (args1 Int)) + (+ args0 args1)) (seq.nth lst 0) (sbv.foldr_5cb25c base (seq.extract lst 1 (- (seq.len lst) 1)))))) [GOOD] ; --- user defined functions --- [GOOD] ; --- assignments --- [GOOD] (define-fun s4 () Bool (= s0 s3)) [GOOD] (define-fun s6 () Bool (= s1 s5)) -[GOOD] (define-fun s8 () Int (seq.len s1)) -[GOOD] (define-fun s9 () Bool (<= s8 s7)) -[GOOD] (define-fun s11 () Int (seq.len s0)) -[GOOD] (define-fun s12 () Bool (>= s8 s11)) -[GOOD] (define-fun s13 () (Seq Int) (seq.extract s0 s7 s8)) -[GOOD] (define-fun s14 () (Seq Int) (ite s12 s0 s13)) -[GOOD] (define-fun s15 () (Seq Int) (ite s9 s10 s14)) -[GOOD] (define-fun s16 () (Seq (SBVTuple2 Int Int)) (seq.mapi (lambda ((l1_s0 Int) (l1_s1 Int)) - ((as mkSBVTuple2 (SBVTuple2 Int Int)) l1_s0 l1_s1)) s7 s15)) -[GOOD] (define-fun s17 () (Seq (SBVTuple2 Int Int)) (seq.map (lambda ((l1_s0 (SBVTuple2 Int Int))) - (let ((l1_s1 (proj_2_SBVTuple2 l1_s0))) - (let ((l1_s2 (proj_1_SBVTuple2 l1_s0))) - (let ((l1_s3 (seq.nth s1 l1_s2))) - (let ((l1_s4 ((as mkSBVTuple2 (SBVTuple2 Int Int)) l1_s1 l1_s3))) - l1_s4))))) s16)) -[GOOD] (define-fun s18 () (Seq Int) (seq.map (lambda ((l1_s0 (SBVTuple2 Int Int))) - (let ((l1_s1 (proj_1_SBVTuple2 l1_s0))) - (let ((l1_s2 (proj_2_SBVTuple2 l1_s0))) - (let ((l1_s3 (+ l1_s1 l1_s2))) - l1_s3)))) s17)) -[GOOD] (define-fun s19 () (Seq Int) (|sbv.reverse_[SInteger]| s18)) -[GOOD] (define-fun s20 () Int (seq.foldl (lambda ((l1_s0 Int) (l1_s1 Int)) - (+ l1_s0 l1_s1)) s7 s19)) -[GOOD] (define-fun s21 () Bool (= s2 s20)) +[GOOD] (define-fun s8 () (Seq (SBVTuple2 Int Int)) (sbv.zip_88576a s0 s1)) +[GOOD] (define-fun s9 () (Seq Int) (sbv.map_cb21ff s8)) +[GOOD] (define-fun s10 () Int (sbv.foldr_5cb25c s7 s9)) +[GOOD] (define-fun s11 () Bool (= s2 s10)) [GOOD] ; --- delayedEqualities --- [GOOD] ; --- formula --- [GOOD] (assert s4) [GOOD] (assert s6) -[GOOD] (assert s21) +[GOOD] (assert s11) [SEND] (check-sat) [RECV] sat [SEND] (get-value (s2)) diff --git a/SBVTestSuite/GoldFiles/lambda24.gold b/SBVTestSuite/GoldFiles/lambda24.gold --- a/SBVTestSuite/GoldFiles/lambda24.gold +++ b/SBVTestSuite/GoldFiles/lambda24.gold @@ -8,18 +8,13 @@ [GOOD] (set-option :pp.max_depth 4294967295) [GOOD] (set-option :pp.min_alias_size 4294967295) [GOOD] (set-option :model.inline_def true ) -[GOOD] (set-logic ALL) ; has unbounded values, using catch-all. +[GOOD] (set-logic ALL) ; has lambda expressions, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- -[GOOD] (declare-datatypes ((SBVTuple2 2)) ((par (T1 T2) - ((mkSBVTuple2 (proj_1_SBVTuple2 T1) - (proj_2_SBVTuple2 T2)))))) [GOOD] ; --- sums --- [GOOD] ; --- literal constants --- [GOOD] (define-fun s3 () (Seq Int) (seq.++ (seq.unit 1) (seq.unit 2) (seq.unit 3) (seq.unit 4) (seq.unit 5) (seq.unit 6) (seq.unit 7) (seq.unit 8) (seq.unit 9) (seq.unit 10))) [GOOD] (define-fun s5 () (Seq Int) (seq.++ (seq.unit 11) (seq.unit 12) (seq.unit 13) (seq.unit 14) (seq.unit 15) (seq.unit 16) (seq.unit 17) (seq.unit 18) (seq.unit 19) (seq.unit 20))) -[GOOD] (define-fun s7 () Int 0) -[GOOD] (define-fun s10 () (Seq Int) (as seq.empty (Seq Int))) [GOOD] ; --- top level inputs --- [GOOD] (declare-fun s0 () (Seq Int)) [GOOD] (declare-fun s1 () (Seq Int)) @@ -27,31 +22,24 @@ [GOOD] ; --- constant tables --- [GOOD] ; --- non-constant tables --- [GOOD] ; --- uninterpreted constants --- +[GOOD] ; --- Firstified function definitions +[GOOD] ; Firstified function: zipWith :: (SInteger -> SInteger -> SInteger) -> [SInteger] -> [SInteger] -> [SInteger] +[GOOD] (define-fun-rec sbv.zipWith_736833 ((lst1 (Seq Int)) (lst2 (Seq Int))) (Seq Int) + (ite (or (= lst1 (as seq.empty (Seq Int))) (= lst2 (as seq.empty (Seq Int)))) + (as seq.empty (Seq Int)) + (seq.++ (seq.unit (select (lambda ((args0 Int) (args1 Int)) + (+ args0 args1)) (seq.nth lst1 0) (seq.nth lst2 0))) (sbv.zipWith_736833 (seq.extract lst1 1 (- (seq.len lst1) 1)) (seq.extract lst2 1 (- (seq.len lst2) 1)))))) [GOOD] ; --- user defined functions --- [GOOD] ; --- assignments --- [GOOD] (define-fun s4 () Bool (= s0 s3)) [GOOD] (define-fun s6 () Bool (= s1 s5)) -[GOOD] (define-fun s8 () Int (seq.len s1)) -[GOOD] (define-fun s9 () Bool (<= s8 s7)) -[GOOD] (define-fun s11 () Int (seq.len s0)) -[GOOD] (define-fun s12 () Bool (>= s8 s11)) -[GOOD] (define-fun s13 () (Seq Int) (seq.extract s0 s7 s8)) -[GOOD] (define-fun s14 () (Seq Int) (ite s12 s0 s13)) -[GOOD] (define-fun s15 () (Seq Int) (ite s9 s10 s14)) -[GOOD] (define-fun s16 () (Seq (SBVTuple2 Int Int)) (seq.mapi (lambda ((l1_s0 Int) (l1_s1 Int)) - ((as mkSBVTuple2 (SBVTuple2 Int Int)) l1_s0 l1_s1)) s7 s15)) -[GOOD] (define-fun s17 () (Seq Int) (seq.map (lambda ((l1_s0 (SBVTuple2 Int Int))) - (let ((l1_s1 (proj_2_SBVTuple2 l1_s0))) - (let ((l1_s2 (proj_1_SBVTuple2 l1_s0))) - (let ((l1_s3 (seq.nth s1 l1_s2))) - (let ((l1_s4 (+ l1_s1 l1_s3))) - l1_s4))))) s16)) -[GOOD] (define-fun s18 () Bool (= s2 s17)) +[GOOD] (define-fun s7 () (Seq Int) (sbv.zipWith_736833 s0 s1)) +[GOOD] (define-fun s8 () Bool (= s2 s7)) [GOOD] ; --- delayedEqualities --- [GOOD] ; --- formula --- [GOOD] (assert s4) [GOOD] (assert s6) -[GOOD] (assert s18) +[GOOD] (assert s8) [SEND] (check-sat) [RECV] sat [SEND] (get-value (s2)) diff --git a/SBVTestSuite/GoldFiles/lambda25.gold b/SBVTestSuite/GoldFiles/lambda25.gold --- a/SBVTestSuite/GoldFiles/lambda25.gold +++ b/SBVTestSuite/GoldFiles/lambda25.gold @@ -8,18 +8,14 @@ [GOOD] (set-option :pp.max_depth 4294967295) [GOOD] (set-option :pp.min_alias_size 4294967295) [GOOD] (set-option :model.inline_def true ) -[GOOD] (set-logic ALL) ; has unbounded values, using catch-all. +[GOOD] (set-logic ALL) ; has lambda expressions, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- -[GOOD] (declare-datatypes ((SBVTuple2 2)) ((par (T1 T2) - ((mkSBVTuple2 (proj_1_SBVTuple2 T1) - (proj_2_SBVTuple2 T2)))))) [GOOD] ; --- sums --- [GOOD] ; --- literal constants --- [GOOD] (define-fun s3 () (Seq Int) (seq.++ (seq.unit 1) (seq.unit 2) (seq.unit 3) (seq.unit 4) (seq.unit 5) (seq.unit 6) (seq.unit 7) (seq.unit 8) (seq.unit 9) (seq.unit 10))) [GOOD] (define-fun s5 () (Seq Int) (seq.++ (seq.unit 10) (seq.unit 9) (seq.unit 8) (seq.unit 7) (seq.unit 6) (seq.unit 5) (seq.unit 4) (seq.unit 3) (seq.unit 2) (seq.unit 1))) [GOOD] (define-fun s7 () Int 0) -[GOOD] (define-fun s10 () (Seq Int) (as seq.empty (Seq Int))) [GOOD] ; --- top level inputs --- [GOOD] (declare-fun s0 () (Seq Int)) [GOOD] (declare-fun s1 () (Seq Int)) @@ -27,39 +23,31 @@ [GOOD] ; --- constant tables --- [GOOD] ; --- non-constant tables --- [GOOD] ; --- uninterpreted constants --- -[GOOD] ; --- SBV Function definitions -[GOOD] (define-fun-rec |sbv.reverse_[SInteger]| ((lst (Seq Int))) (Seq Int) +[GOOD] ; --- Firstified function definitions +[GOOD] ; Firstified function: zipWith :: (SInteger -> SInteger -> SInteger) -> [SInteger] -> [SInteger] -> [SInteger] +[GOOD] (define-fun-rec sbv.zipWith_736833 ((lst1 (Seq Int)) (lst2 (Seq Int))) (Seq Int) + (ite (or (= lst1 (as seq.empty (Seq Int))) (= lst2 (as seq.empty (Seq Int)))) + (as seq.empty (Seq Int)) + (seq.++ (seq.unit (select (lambda ((args0 Int) (args1 Int)) + (+ args0 args1)) (seq.nth lst1 0) (seq.nth lst2 0))) (sbv.zipWith_736833 (seq.extract lst1 1 (- (seq.len lst1) 1)) (seq.extract lst2 1 (- (seq.len lst2) 1)))))) +[GOOD] ; Firstified function: foldr :: (SInteger -> SInteger -> SInteger) -> SInteger -> [SInteger] -> SInteger +[GOOD] (define-fun-rec sbv.foldr_5cb25c ((base Int) (lst (Seq Int))) Int (ite (= lst (as seq.empty (Seq Int))) - (as seq.empty (Seq Int)) - (seq.++ (|sbv.reverse_[SInteger]| (seq.extract lst 1 (- (seq.len lst) 1))) (seq.unit (seq.nth lst 0))))) + base + (select (lambda ((args0 Int) (args1 Int)) + (+ args0 args1)) (seq.nth lst 0) (sbv.foldr_5cb25c base (seq.extract lst 1 (- (seq.len lst) 1)))))) [GOOD] ; --- user defined functions --- [GOOD] ; --- assignments --- [GOOD] (define-fun s4 () Bool (= s0 s3)) [GOOD] (define-fun s6 () Bool (= s1 s5)) -[GOOD] (define-fun s8 () Int (seq.len s1)) -[GOOD] (define-fun s9 () Bool (<= s8 s7)) -[GOOD] (define-fun s11 () Int (seq.len s0)) -[GOOD] (define-fun s12 () Bool (>= s8 s11)) -[GOOD] (define-fun s13 () (Seq Int) (seq.extract s0 s7 s8)) -[GOOD] (define-fun s14 () (Seq Int) (ite s12 s0 s13)) -[GOOD] (define-fun s15 () (Seq Int) (ite s9 s10 s14)) -[GOOD] (define-fun s16 () (Seq (SBVTuple2 Int Int)) (seq.mapi (lambda ((l1_s0 Int) (l1_s1 Int)) - ((as mkSBVTuple2 (SBVTuple2 Int Int)) l1_s0 l1_s1)) s7 s15)) -[GOOD] (define-fun s17 () (Seq Int) (seq.map (lambda ((l1_s0 (SBVTuple2 Int Int))) - (let ((l1_s1 (proj_2_SBVTuple2 l1_s0))) - (let ((l1_s2 (proj_1_SBVTuple2 l1_s0))) - (let ((l1_s3 (seq.nth s1 l1_s2))) - (let ((l1_s4 (+ l1_s1 l1_s3))) - l1_s4))))) s16)) -[GOOD] (define-fun s18 () (Seq Int) (|sbv.reverse_[SInteger]| s17)) -[GOOD] (define-fun s19 () Int (seq.foldl (lambda ((l1_s0 Int) (l1_s1 Int)) - (+ l1_s0 l1_s1)) s7 s18)) -[GOOD] (define-fun s20 () Bool (= s2 s19)) +[GOOD] (define-fun s8 () (Seq Int) (sbv.zipWith_736833 s0 s1)) +[GOOD] (define-fun s9 () Int (sbv.foldr_5cb25c s7 s8)) +[GOOD] (define-fun s10 () Bool (= s2 s9)) [GOOD] ; --- delayedEqualities --- [GOOD] ; --- formula --- [GOOD] (assert s4) [GOOD] (assert s6) -[GOOD] (assert s20) +[GOOD] (assert s10) [SEND] (check-sat) [RECV] sat [SEND] (get-value (s2)) diff --git a/SBVTestSuite/GoldFiles/lambda26.gold b/SBVTestSuite/GoldFiles/lambda26.gold --- a/SBVTestSuite/GoldFiles/lambda26.gold +++ b/SBVTestSuite/GoldFiles/lambda26.gold @@ -14,23 +14,27 @@ [GOOD] ; --- sums --- [GOOD] ; --- literal constants --- [GOOD] (define-fun s2 () (Seq (Seq Int)) (seq.++ (seq.unit (seq.++ (seq.unit 1) (seq.unit 2) (seq.unit 3) (seq.unit 4) (seq.unit 5))) (seq.unit (seq.++ (seq.unit 1) (seq.unit 2) (seq.unit 3) (seq.unit 4) (seq.unit 5) (seq.unit 6) (seq.unit 7) (seq.unit 8) (seq.unit 9) (seq.unit 10))) (seq.unit (seq.++ (seq.unit 1) (seq.unit 2) (seq.unit 3) (seq.unit 4) (seq.unit 5) (seq.unit 6) (seq.unit 7) (seq.unit 8) (seq.unit 9) (seq.unit 10) (seq.unit 11) (seq.unit 12) (seq.unit 13) (seq.unit 14) (seq.unit 15) (seq.unit 16) (seq.unit 17) (seq.unit 18) (seq.unit 19) (seq.unit 20))))) -[GOOD] (define-fun s4 () (Seq Int) (as seq.empty (Seq Int))) [GOOD] ; --- top level inputs --- [GOOD] (declare-fun s0 () (Seq (Seq Int))) [GOOD] (declare-fun s1 () (Seq Int)) [GOOD] ; --- constant tables --- [GOOD] ; --- non-constant tables --- [GOOD] ; --- uninterpreted constants --- +[GOOD] ; --- Firstified function definitions +[GOOD] ; Firstified function: concat :: [[SInteger]] -> [SInteger] +[GOOD] (define-fun-rec sbv.concat_712066 ((lst (Seq (Seq Int)))) (Seq Int) + (ite (= lst (as seq.empty (Seq (Seq Int)))) + (as seq.empty (Seq Int)) + (seq.++ (seq.nth lst 0) (sbv.concat_712066 (seq.extract lst 1 (- (seq.len lst) 1)))))) [GOOD] ; --- user defined functions --- [GOOD] ; --- assignments --- [GOOD] (define-fun s3 () Bool (= s0 s2)) -[GOOD] (define-fun s5 () (Seq Int) (seq.foldl (lambda ((l1_s0 (Seq Int)) (l1_s1 (Seq Int))) - (seq.++ l1_s0 l1_s1)) s4 s0)) -[GOOD] (define-fun s6 () Bool (= s1 s5)) +[GOOD] (define-fun s4 () (Seq Int) (sbv.concat_712066 s0)) +[GOOD] (define-fun s5 () Bool (= s1 s4)) [GOOD] ; --- delayedEqualities --- [GOOD] ; --- formula --- [GOOD] (assert s3) -[GOOD] (assert s6) +[GOOD] (assert s5) [SEND] (check-sat) [RECV] sat [SEND] (get-value (s1)) diff --git a/SBVTestSuite/GoldFiles/lambda27.gold b/SBVTestSuite/GoldFiles/lambda27.gold --- a/SBVTestSuite/GoldFiles/lambda27.gold +++ b/SBVTestSuite/GoldFiles/lambda27.gold @@ -8,7 +8,7 @@ [GOOD] (set-option :pp.max_depth 4294967295) [GOOD] (set-option :pp.min_alias_size 4294967295) [GOOD] (set-option :model.inline_def true ) -[GOOD] (set-logic ALL) ; has unbounded values, using catch-all. +[GOOD] (set-logic ALL) ; has lambda expressions, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums --- @@ -20,31 +20,36 @@ [GOOD] ; --- constant tables --- [GOOD] ; --- non-constant tables --- [GOOD] ; --- uninterpreted constants --- +[GOOD] ; --- Firstified function definitions +[GOOD] ; Firstified function: all :: (SInteger -> SBool) -> [SInteger] -> SBool +[GOOD] (define-fun-rec sbv.all_f82c1b ((lst (Seq Int))) Bool + (ite (= lst (as seq.empty (Seq Int))) + true + (and (select (lambda ((args0 Int)) + (let ((args1 2)) + (let ((args3 0)) + (let ((args7 1)) + (let ((args13 (- 1))) + (let ((args2 (mod args0 args1))) + (let ((args4 (>= args0 args3))) + (let ((args5 (= args2 args3))) + (let ((args6 (or args4 args5))) + (let ((args8 (ite args6 args3 args7))) + (let ((args9 (* args1 args8))) + (let ((args10 (- args2 args9))) + (let ((args11 (> args10 args3))) + (let ((args12 (< args10 args3))) + (let ((args14 (ite args12 args13 args10))) + (let ((args15 (ite args11 args7 args14))) + (let ((args16 (= args13 args15))) + (let ((args17 (+ args1 args10))) + (let ((args18 (ite args16 args17 args10))) + (let ((args19 (= args3 args18))) + args19)))))))))))))))))))) (seq.nth lst 0)) (sbv.all_f82c1b (seq.extract lst 1 (- (seq.len lst) 1)))))) [GOOD] ; --- user defined functions --- [GOOD] ; --- assignments --- [GOOD] (define-fun s3 () Bool (= s0 s2)) -[GOOD] (define-fun s4 () Bool (seq.foldl (lambda ((l1_s0 Bool) (l1_s1 Int)) - (let ((l1_s2 2)) - (let ((l1_s4 0)) - (let ((l1_s8 1)) - (let ((l1_s14 (- 1))) - (let ((l1_s3 (mod l1_s1 l1_s2))) - (let ((l1_s5 (>= l1_s1 l1_s4))) - (let ((l1_s6 (= l1_s3 l1_s4))) - (let ((l1_s7 (or l1_s5 l1_s6))) - (let ((l1_s9 (ite l1_s7 l1_s4 l1_s8))) - (let ((l1_s10 (* l1_s2 l1_s9))) - (let ((l1_s11 (- l1_s3 l1_s10))) - (let ((l1_s12 (> l1_s11 l1_s4))) - (let ((l1_s13 (< l1_s11 l1_s4))) - (let ((l1_s15 (ite l1_s13 l1_s14 l1_s11))) - (let ((l1_s16 (ite l1_s12 l1_s8 l1_s15))) - (let ((l1_s17 (= l1_s14 l1_s16))) - (let ((l1_s18 (+ l1_s2 l1_s11))) - (let ((l1_s19 (ite l1_s17 l1_s18 l1_s11))) - (let ((l1_s20 (= l1_s4 l1_s19))) - (let ((l1_s21 (and l1_s0 l1_s20))) - l1_s21))))))))))))))))))))) true s0)) +[GOOD] (define-fun s4 () Bool (sbv.all_f82c1b s0)) [GOOD] (define-fun s5 () Bool (= s1 s4)) [GOOD] ; --- delayedEqualities --- [GOOD] ; --- formula --- diff --git a/SBVTestSuite/GoldFiles/lambda28.gold b/SBVTestSuite/GoldFiles/lambda28.gold --- a/SBVTestSuite/GoldFiles/lambda28.gold +++ b/SBVTestSuite/GoldFiles/lambda28.gold @@ -8,7 +8,7 @@ [GOOD] (set-option :pp.max_depth 4294967295) [GOOD] (set-option :pp.min_alias_size 4294967295) [GOOD] (set-option :model.inline_def true ) -[GOOD] (set-logic ALL) ; has unbounded values, using catch-all. +[GOOD] (set-logic ALL) ; has lambda expressions, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums --- @@ -20,31 +20,36 @@ [GOOD] ; --- constant tables --- [GOOD] ; --- non-constant tables --- [GOOD] ; --- uninterpreted constants --- +[GOOD] ; --- Firstified function definitions +[GOOD] ; Firstified function: all :: (SInteger -> SBool) -> [SInteger] -> SBool +[GOOD] (define-fun-rec sbv.all_f82c1b ((lst (Seq Int))) Bool + (ite (= lst (as seq.empty (Seq Int))) + true + (and (select (lambda ((args0 Int)) + (let ((args1 2)) + (let ((args3 0)) + (let ((args7 1)) + (let ((args13 (- 1))) + (let ((args2 (mod args0 args1))) + (let ((args4 (>= args0 args3))) + (let ((args5 (= args2 args3))) + (let ((args6 (or args4 args5))) + (let ((args8 (ite args6 args3 args7))) + (let ((args9 (* args1 args8))) + (let ((args10 (- args2 args9))) + (let ((args11 (> args10 args3))) + (let ((args12 (< args10 args3))) + (let ((args14 (ite args12 args13 args10))) + (let ((args15 (ite args11 args7 args14))) + (let ((args16 (= args13 args15))) + (let ((args17 (+ args1 args10))) + (let ((args18 (ite args16 args17 args10))) + (let ((args19 (= args3 args18))) + args19)))))))))))))))))))) (seq.nth lst 0)) (sbv.all_f82c1b (seq.extract lst 1 (- (seq.len lst) 1)))))) [GOOD] ; --- user defined functions --- [GOOD] ; --- assignments --- [GOOD] (define-fun s3 () Bool (= s0 s2)) -[GOOD] (define-fun s4 () Bool (seq.foldl (lambda ((l1_s0 Bool) (l1_s1 Int)) - (let ((l1_s2 2)) - (let ((l1_s4 0)) - (let ((l1_s8 1)) - (let ((l1_s14 (- 1))) - (let ((l1_s3 (mod l1_s1 l1_s2))) - (let ((l1_s5 (>= l1_s1 l1_s4))) - (let ((l1_s6 (= l1_s3 l1_s4))) - (let ((l1_s7 (or l1_s5 l1_s6))) - (let ((l1_s9 (ite l1_s7 l1_s4 l1_s8))) - (let ((l1_s10 (* l1_s2 l1_s9))) - (let ((l1_s11 (- l1_s3 l1_s10))) - (let ((l1_s12 (> l1_s11 l1_s4))) - (let ((l1_s13 (< l1_s11 l1_s4))) - (let ((l1_s15 (ite l1_s13 l1_s14 l1_s11))) - (let ((l1_s16 (ite l1_s12 l1_s8 l1_s15))) - (let ((l1_s17 (= l1_s14 l1_s16))) - (let ((l1_s18 (+ l1_s2 l1_s11))) - (let ((l1_s19 (ite l1_s17 l1_s18 l1_s11))) - (let ((l1_s20 (= l1_s4 l1_s19))) - (let ((l1_s21 (and l1_s0 l1_s20))) - l1_s21))))))))))))))))))))) true s0)) +[GOOD] (define-fun s4 () Bool (sbv.all_f82c1b s0)) [GOOD] (define-fun s5 () Bool (= s1 s4)) [GOOD] ; --- delayedEqualities --- [GOOD] ; --- formula --- diff --git a/SBVTestSuite/GoldFiles/lambda29.gold b/SBVTestSuite/GoldFiles/lambda29.gold --- a/SBVTestSuite/GoldFiles/lambda29.gold +++ b/SBVTestSuite/GoldFiles/lambda29.gold @@ -8,7 +8,7 @@ [GOOD] (set-option :pp.max_depth 4294967295) [GOOD] (set-option :pp.min_alias_size 4294967295) [GOOD] (set-option :model.inline_def true ) -[GOOD] (set-logic ALL) ; has unbounded values, using catch-all. +[GOOD] (set-logic ALL) ; has lambda expressions, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums --- @@ -20,31 +20,36 @@ [GOOD] ; --- constant tables --- [GOOD] ; --- non-constant tables --- [GOOD] ; --- uninterpreted constants --- +[GOOD] ; --- Firstified function definitions +[GOOD] ; Firstified function: any :: (SInteger -> SBool) -> [SInteger] -> SBool +[GOOD] (define-fun-rec sbv.any_ca4250 ((lst (Seq Int))) Bool + (ite (= lst (as seq.empty (Seq Int))) + false + (or (select (lambda ((args0 Int)) + (let ((args1 2)) + (let ((args3 0)) + (let ((args7 1)) + (let ((args13 (- 1))) + (let ((args2 (mod args0 args1))) + (let ((args4 (>= args0 args3))) + (let ((args5 (= args2 args3))) + (let ((args6 (or args4 args5))) + (let ((args8 (ite args6 args3 args7))) + (let ((args9 (* args1 args8))) + (let ((args10 (- args2 args9))) + (let ((args11 (> args10 args3))) + (let ((args12 (< args10 args3))) + (let ((args14 (ite args12 args13 args10))) + (let ((args15 (ite args11 args7 args14))) + (let ((args16 (= args13 args15))) + (let ((args17 (+ args1 args10))) + (let ((args18 (ite args16 args17 args10))) + (let ((args19 (distinct args3 args18))) + args19)))))))))))))))))))) (seq.nth lst 0)) (sbv.any_ca4250 (seq.extract lst 1 (- (seq.len lst) 1)))))) [GOOD] ; --- user defined functions --- [GOOD] ; --- assignments --- [GOOD] (define-fun s3 () Bool (= s0 s2)) -[GOOD] (define-fun s4 () Bool (seq.foldl (lambda ((l1_s0 Bool) (l1_s1 Int)) - (let ((l1_s2 2)) - (let ((l1_s4 0)) - (let ((l1_s8 1)) - (let ((l1_s14 (- 1))) - (let ((l1_s3 (mod l1_s1 l1_s2))) - (let ((l1_s5 (>= l1_s1 l1_s4))) - (let ((l1_s6 (= l1_s3 l1_s4))) - (let ((l1_s7 (or l1_s5 l1_s6))) - (let ((l1_s9 (ite l1_s7 l1_s4 l1_s8))) - (let ((l1_s10 (* l1_s2 l1_s9))) - (let ((l1_s11 (- l1_s3 l1_s10))) - (let ((l1_s12 (> l1_s11 l1_s4))) - (let ((l1_s13 (< l1_s11 l1_s4))) - (let ((l1_s15 (ite l1_s13 l1_s14 l1_s11))) - (let ((l1_s16 (ite l1_s12 l1_s8 l1_s15))) - (let ((l1_s17 (= l1_s14 l1_s16))) - (let ((l1_s18 (+ l1_s2 l1_s11))) - (let ((l1_s19 (ite l1_s17 l1_s18 l1_s11))) - (let ((l1_s20 (distinct l1_s4 l1_s19))) - (let ((l1_s21 (or l1_s0 l1_s20))) - l1_s21))))))))))))))))))))) false s0)) +[GOOD] (define-fun s4 () Bool (sbv.any_ca4250 s0)) [GOOD] (define-fun s5 () Bool (= s1 s4)) [GOOD] ; --- delayedEqualities --- [GOOD] ; --- formula --- diff --git a/SBVTestSuite/GoldFiles/lambda30.gold b/SBVTestSuite/GoldFiles/lambda30.gold --- a/SBVTestSuite/GoldFiles/lambda30.gold +++ b/SBVTestSuite/GoldFiles/lambda30.gold @@ -8,7 +8,7 @@ [GOOD] (set-option :pp.max_depth 4294967295) [GOOD] (set-option :pp.min_alias_size 4294967295) [GOOD] (set-option :model.inline_def true ) -[GOOD] (set-logic ALL) ; has unbounded values, using catch-all. +[GOOD] (set-logic ALL) ; has lambda expressions, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums --- @@ -20,31 +20,36 @@ [GOOD] ; --- constant tables --- [GOOD] ; --- non-constant tables --- [GOOD] ; --- uninterpreted constants --- +[GOOD] ; --- Firstified function definitions +[GOOD] ; Firstified function: any :: (SInteger -> SBool) -> [SInteger] -> SBool +[GOOD] (define-fun-rec sbv.any_fec105 ((lst (Seq Int))) Bool + (ite (= lst (as seq.empty (Seq Int))) + false + (or (select (lambda ((args0 Int)) + (let ((args1 2)) + (let ((args3 0)) + (let ((args7 1)) + (let ((args13 (- 1))) + (let ((args2 (mod args0 args1))) + (let ((args4 (>= args0 args3))) + (let ((args5 (= args2 args3))) + (let ((args6 (or args4 args5))) + (let ((args8 (ite args6 args3 args7))) + (let ((args9 (* args1 args8))) + (let ((args10 (- args2 args9))) + (let ((args11 (> args10 args3))) + (let ((args12 (< args10 args3))) + (let ((args14 (ite args12 args13 args10))) + (let ((args15 (ite args11 args7 args14))) + (let ((args16 (= args13 args15))) + (let ((args17 (+ args1 args10))) + (let ((args18 (ite args16 args17 args10))) + (let ((args19 (= args3 args18))) + args19)))))))))))))))))))) (seq.nth lst 0)) (sbv.any_fec105 (seq.extract lst 1 (- (seq.len lst) 1)))))) [GOOD] ; --- user defined functions --- [GOOD] ; --- assignments --- [GOOD] (define-fun s3 () Bool (= s0 s2)) -[GOOD] (define-fun s4 () Bool (seq.foldl (lambda ((l1_s0 Bool) (l1_s1 Int)) - (let ((l1_s2 2)) - (let ((l1_s4 0)) - (let ((l1_s8 1)) - (let ((l1_s14 (- 1))) - (let ((l1_s3 (mod l1_s1 l1_s2))) - (let ((l1_s5 (>= l1_s1 l1_s4))) - (let ((l1_s6 (= l1_s3 l1_s4))) - (let ((l1_s7 (or l1_s5 l1_s6))) - (let ((l1_s9 (ite l1_s7 l1_s4 l1_s8))) - (let ((l1_s10 (* l1_s2 l1_s9))) - (let ((l1_s11 (- l1_s3 l1_s10))) - (let ((l1_s12 (> l1_s11 l1_s4))) - (let ((l1_s13 (< l1_s11 l1_s4))) - (let ((l1_s15 (ite l1_s13 l1_s14 l1_s11))) - (let ((l1_s16 (ite l1_s12 l1_s8 l1_s15))) - (let ((l1_s17 (= l1_s14 l1_s16))) - (let ((l1_s18 (+ l1_s2 l1_s11))) - (let ((l1_s19 (ite l1_s17 l1_s18 l1_s11))) - (let ((l1_s20 (= l1_s4 l1_s19))) - (let ((l1_s21 (or l1_s0 l1_s20))) - l1_s21))))))))))))))))))))) false s0)) +[GOOD] (define-fun s4 () Bool (sbv.any_fec105 s0)) [GOOD] (define-fun s5 () Bool (= s1 s4)) [GOOD] ; --- delayedEqualities --- [GOOD] ; --- formula --- diff --git a/SBVTestSuite/GoldFiles/lambda31.gold b/SBVTestSuite/GoldFiles/lambda31.gold --- a/SBVTestSuite/GoldFiles/lambda31.gold +++ b/SBVTestSuite/GoldFiles/lambda31.gold @@ -8,52 +8,56 @@ [GOOD] (set-option :pp.max_depth 4294967295) [GOOD] (set-option :pp.min_alias_size 4294967295) [GOOD] (set-option :model.inline_def true ) -[GOOD] (set-logic ALL) ; has unbounded values, using catch-all. +[GOOD] (set-logic ALL) ; has lambda expressions, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums --- [GOOD] ; --- literal constants --- [GOOD] (define-fun s2 () (Seq Int) (seq.++ (seq.unit 1) (seq.unit 2) (seq.unit 3) (seq.unit 4) (seq.unit 5) (seq.unit 6) (seq.unit 7) (seq.unit 8) (seq.unit 9) (seq.unit 10))) -[GOOD] (define-fun s4 () (Seq Int) (as seq.empty (Seq Int))) [GOOD] ; --- top level inputs --- [GOOD] (declare-fun s0 () (Seq Int)) [GOOD] (declare-fun s1 () (Seq Int)) [GOOD] ; --- constant tables --- [GOOD] ; --- non-constant tables --- [GOOD] ; --- uninterpreted constants --- +[GOOD] ; --- Firstified function definitions +[GOOD] ; Firstified function: filter :: (SInteger -> SBool) -> [SInteger] -> [SInteger] +[GOOD] (define-fun-rec sbv.filter_75abb5 ((lst (Seq Int))) (Seq Int) + (ite (= lst (as seq.empty (Seq Int))) + (as seq.empty (Seq Int)) + (let ((rest (sbv.filter_75abb5 (seq.extract lst 1 (- (seq.len lst) 1))))) + (ite (select (lambda ((args0 Int)) + (let ((args1 2)) + (let ((args3 0)) + (let ((args7 1)) + (let ((args13 (- 1))) + (let ((args2 (mod args0 args1))) + (let ((args4 (>= args0 args3))) + (let ((args5 (= args2 args3))) + (let ((args6 (or args4 args5))) + (let ((args8 (ite args6 args3 args7))) + (let ((args9 (* args1 args8))) + (let ((args10 (- args2 args9))) + (let ((args11 (> args10 args3))) + (let ((args12 (< args10 args3))) + (let ((args14 (ite args12 args13 args10))) + (let ((args15 (ite args11 args7 args14))) + (let ((args16 (= args13 args15))) + (let ((args17 (+ args1 args10))) + (let ((args18 (ite args16 args17 args10))) + (let ((args19 (= args3 args18))) + args19)))))))))))))))))))) (seq.nth lst 0)) + (seq.++ (seq.unit (seq.nth lst 0)) rest) + rest)))) [GOOD] ; --- user defined functions --- [GOOD] ; --- assignments --- [GOOD] (define-fun s3 () Bool (= s0 s2)) -[GOOD] (define-fun s5 () (Seq Int) (seq.foldl (lambda ((l1_s0 (Seq Int)) (l1_s1 Int)) - (let ((l1_s2 2)) - (let ((l1_s4 0)) - (let ((l1_s8 1)) - (let ((l1_s14 (- 1))) - (let ((l1_s22 (as seq.empty (Seq Int)))) - (let ((l1_s3 (mod l1_s1 l1_s2))) - (let ((l1_s5 (>= l1_s1 l1_s4))) - (let ((l1_s6 (= l1_s3 l1_s4))) - (let ((l1_s7 (or l1_s5 l1_s6))) - (let ((l1_s9 (ite l1_s7 l1_s4 l1_s8))) - (let ((l1_s10 (* l1_s2 l1_s9))) - (let ((l1_s11 (- l1_s3 l1_s10))) - (let ((l1_s12 (> l1_s11 l1_s4))) - (let ((l1_s13 (< l1_s11 l1_s4))) - (let ((l1_s15 (ite l1_s13 l1_s14 l1_s11))) - (let ((l1_s16 (ite l1_s12 l1_s8 l1_s15))) - (let ((l1_s17 (= l1_s14 l1_s16))) - (let ((l1_s18 (+ l1_s2 l1_s11))) - (let ((l1_s19 (ite l1_s17 l1_s18 l1_s11))) - (let ((l1_s20 (= l1_s4 l1_s19))) - (let ((l1_s21 (seq.unit l1_s1))) - (let ((l1_s23 (ite l1_s20 l1_s21 l1_s22))) - (let ((l1_s24 (seq.++ l1_s0 l1_s23))) - l1_s24)))))))))))))))))))))))) s4 s0)) -[GOOD] (define-fun s6 () Bool (= s1 s5)) +[GOOD] (define-fun s4 () (Seq Int) (sbv.filter_75abb5 s0)) +[GOOD] (define-fun s5 () Bool (= s1 s4)) [GOOD] ; --- delayedEqualities --- [GOOD] ; --- formula --- [GOOD] (assert s3) -[GOOD] (assert s6) +[GOOD] (assert s5) [SEND] (check-sat) [RECV] sat [SEND] (get-value (s1)) diff --git a/SBVTestSuite/GoldFiles/lambda32.gold b/SBVTestSuite/GoldFiles/lambda32.gold --- a/SBVTestSuite/GoldFiles/lambda32.gold +++ b/SBVTestSuite/GoldFiles/lambda32.gold @@ -8,52 +8,56 @@ [GOOD] (set-option :pp.max_depth 4294967295) [GOOD] (set-option :pp.min_alias_size 4294967295) [GOOD] (set-option :model.inline_def true ) -[GOOD] (set-logic ALL) ; has unbounded values, using catch-all. +[GOOD] (set-logic ALL) ; has lambda expressions, using catch-all. [GOOD] ; --- uninterpreted sorts --- [GOOD] ; --- tuples --- [GOOD] ; --- sums --- [GOOD] ; --- literal constants --- [GOOD] (define-fun s2 () (Seq Int) (seq.++ (seq.unit 1) (seq.unit 2) (seq.unit 3) (seq.unit 4) (seq.unit 5) (seq.unit 6) (seq.unit 7) (seq.unit 8) (seq.unit 9) (seq.unit 10))) -[GOOD] (define-fun s4 () (Seq Int) (as seq.empty (Seq Int))) [GOOD] ; --- top level inputs --- [GOOD] (declare-fun s0 () (Seq Int)) [GOOD] (declare-fun s1 () (Seq Int)) [GOOD] ; --- constant tables --- [GOOD] ; --- non-constant tables --- [GOOD] ; --- uninterpreted constants --- +[GOOD] ; --- Firstified function definitions +[GOOD] ; Firstified function: filter :: (SInteger -> SBool) -> [SInteger] -> [SInteger] +[GOOD] (define-fun-rec sbv.filter_86847f ((lst (Seq Int))) (Seq Int) + (ite (= lst (as seq.empty (Seq Int))) + (as seq.empty (Seq Int)) + (let ((rest (sbv.filter_86847f (seq.extract lst 1 (- (seq.len lst) 1))))) + (ite (select (lambda ((args0 Int)) + (let ((args1 2)) + (let ((args3 0)) + (let ((args7 1)) + (let ((args13 (- 1))) + (let ((args2 (mod args0 args1))) + (let ((args4 (>= args0 args3))) + (let ((args5 (= args2 args3))) + (let ((args6 (or args4 args5))) + (let ((args8 (ite args6 args3 args7))) + (let ((args9 (* args1 args8))) + (let ((args10 (- args2 args9))) + (let ((args11 (> args10 args3))) + (let ((args12 (< args10 args3))) + (let ((args14 (ite args12 args13 args10))) + (let ((args15 (ite args11 args7 args14))) + (let ((args16 (= args13 args15))) + (let ((args17 (+ args1 args10))) + (let ((args18 (ite args16 args17 args10))) + (let ((args19 (distinct args3 args18))) + args19)))))))))))))))))))) (seq.nth lst 0)) + (seq.++ (seq.unit (seq.nth lst 0)) rest) + rest)))) [GOOD] ; --- user defined functions --- [GOOD] ; --- assignments --- [GOOD] (define-fun s3 () Bool (= s0 s2)) -[GOOD] (define-fun s5 () (Seq Int) (seq.foldl (lambda ((l1_s0 (Seq Int)) (l1_s1 Int)) - (let ((l1_s2 2)) - (let ((l1_s4 0)) - (let ((l1_s8 1)) - (let ((l1_s14 (- 1))) - (let ((l1_s22 (as seq.empty (Seq Int)))) - (let ((l1_s3 (mod l1_s1 l1_s2))) - (let ((l1_s5 (>= l1_s1 l1_s4))) - (let ((l1_s6 (= l1_s3 l1_s4))) - (let ((l1_s7 (or l1_s5 l1_s6))) - (let ((l1_s9 (ite l1_s7 l1_s4 l1_s8))) - (let ((l1_s10 (* l1_s2 l1_s9))) - (let ((l1_s11 (- l1_s3 l1_s10))) - (let ((l1_s12 (> l1_s11 l1_s4))) - (let ((l1_s13 (< l1_s11 l1_s4))) - (let ((l1_s15 (ite l1_s13 l1_s14 l1_s11))) - (let ((l1_s16 (ite l1_s12 l1_s8 l1_s15))) - (let ((l1_s17 (= l1_s14 l1_s16))) - (let ((l1_s18 (+ l1_s2 l1_s11))) - (let ((l1_s19 (ite l1_s17 l1_s18 l1_s11))) - (let ((l1_s20 (distinct l1_s4 l1_s19))) - (let ((l1_s21 (seq.unit l1_s1))) - (let ((l1_s23 (ite l1_s20 l1_s21 l1_s22))) - (let ((l1_s24 (seq.++ l1_s0 l1_s23))) - l1_s24)))))))))))))))))))))))) s4 s0)) -[GOOD] (define-fun s6 () Bool (= s1 s5)) +[GOOD] (define-fun s4 () (Seq Int) (sbv.filter_86847f s0)) +[GOOD] (define-fun s5 () Bool (= s1 s4)) [GOOD] ; --- delayedEqualities --- [GOOD] ; --- formula --- [GOOD] (assert s3) -[GOOD] (assert s6) +[GOOD] (assert s5) [SEND] (check-sat) [RECV] sat [SEND] (get-value (s1)) diff --git a/SBVTestSuite/GoldFiles/lambda57.gold b/SBVTestSuite/GoldFiles/lambda57.gold --- a/SBVTestSuite/GoldFiles/lambda57.gold +++ b/SBVTestSuite/GoldFiles/lambda57.gold @@ -61,7 +61,7 @@ (let ((l3_s10 (bvadd l3_s3 l3_s9))) (let ((l3_s11 (ite l3_s2 l3_s1 l3_s10))) l3_s11))))))))))) - ; Definition of: f4 :: SWord8 -> SWord8. [Refers to: f4, f1] + ; Definition of: f4 :: SWord8 -> SWord8. [Refers to: f1, f4] (let ((l4_s1 #x00)) (let ((l4_s3 #x01)) (let ((l4_s6 #x02)) diff --git a/SBVTestSuite/GoldFiles/lambda81.gold b/SBVTestSuite/GoldFiles/lambda81.gold new file mode 100644 --- /dev/null +++ b/SBVTestSuite/GoldFiles/lambda81.gold @@ -0,0 +1,10 @@ +CAUGHT EXCEPTION + + +*** Data.SBV.Lambda: Detected nested lambda-definitions. +*** +*** SBV uses firstification to deal-with lambdas, and SMTLib's first-order nature does not allow +*** for easy translation of nested lambdas. As SMTLib gets higher-order features, SBV will eventually +*** relax this restriction. In the mean-time, please rewrite your program without using nested-lambdas +*** if possible. If this workaround isn't applicable, please report this as a use-case for further +*** possible enhancements. diff --git a/SBVTestSuite/GoldFiles/mapNoFailure.gold b/SBVTestSuite/GoldFiles/mapNoFailure.gold deleted file mode 100644 --- a/SBVTestSuite/GoldFiles/mapNoFailure.gold +++ /dev/null @@ -1,157 +0,0 @@ -** 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-option :pp.max_depth 4294967295) -[GOOD] (set-option :pp.min_alias_size 4294967295) -[GOOD] (set-option :model.inline_def true ) -[GOOD] (set-logic ALL) ; has unbounded values, using catch-all. -[GOOD] ; --- uninterpreted sorts --- -[GOOD] ; --- tuples --- -[GOOD] ; --- sums --- -[GOOD] ; --- literal constants --- -[GOOD] (define-fun s5 () Int 6) -[GOOD] (define-fun s7 () Int 0) -[GOOD] (define-fun s20 () Int 1) -[GOOD] (define-fun s59 () Int 10) -[GOOD] ; --- top level inputs --- -[GOOD] (declare-fun s0 () Int) ; tracks user variable "a" -[GOOD] (declare-fun s1 () Int) ; tracks user variable "b" -[GOOD] (declare-fun s2 () Int) ; tracks user variable "c" -[GOOD] ; --- constant tables --- -[GOOD] ; --- non-constant tables --- -[GOOD] ; --- uninterpreted constants --- -[GOOD] ; --- user defined functions --- -[GOOD] ; --- assignments --- -[GOOD] (define-fun s3 () Int (+ s0 s1)) -[GOOD] (define-fun s4 () Int (+ s2 s3)) -[GOOD] (define-fun s6 () Bool (= s4 s5)) -[GOOD] (define-fun s8 () Bool (> s0 s7)) -[GOOD] (define-fun s9 () Bool (> s1 s7)) -[GOOD] (define-fun s10 () Bool (> s2 s7)) -[GOOD] (define-fun s11 () Bool (and s9 s10)) -[GOOD] (define-fun s12 () Bool (and s8 s11)) -[GOOD] (define-fun s13 () (Seq Int) (seq.unit s0)) -[GOOD] (define-fun s14 () (Seq Int) (seq.unit s1)) -[GOOD] (define-fun s15 () (Seq Int) (seq.unit s2)) -[GOOD] (define-fun s16 () (Seq Int) (seq.++ s14 s15)) -[GOOD] (define-fun s17 () (Seq Int) (seq.++ s13 s16)) -[GOOD] (define-fun s18 () Int (seq.len s17)) -[GOOD] (define-fun s19 () Bool (= s7 s18)) -[GOOD] (define-fun s21 () Int (- s18 s20)) -[GOOD] (define-fun s22 () (Seq Int) (seq.extract s17 s20 s21)) -[GOOD] (define-fun s23 () Int (seq.len s22)) -[GOOD] (define-fun s24 () Bool (= s7 s23)) -[GOOD] (define-fun s25 () Int (- s23 s20)) -[GOOD] (define-fun s26 () (Seq Int) (seq.extract s22 s20 s25)) -[GOOD] (define-fun s27 () Int (seq.len s26)) -[GOOD] (define-fun s28 () Bool (= s7 s27)) -[GOOD] (define-fun s29 () Int (- s27 s20)) -[GOOD] (define-fun s30 () (Seq Int) (seq.extract s26 s20 s29)) -[GOOD] (define-fun s31 () Int (seq.len s30)) -[GOOD] (define-fun s32 () Bool (= s7 s31)) -[GOOD] (define-fun s33 () Int (- s31 s20)) -[GOOD] (define-fun s34 () (Seq Int) (seq.extract s30 s20 s33)) -[GOOD] (define-fun s35 () Int (seq.len s34)) -[GOOD] (define-fun s36 () Bool (= s7 s35)) -[GOOD] (define-fun s37 () Int (- s35 s20)) -[GOOD] (define-fun s38 () (Seq Int) (seq.extract s34 s20 s37)) -[GOOD] (define-fun s39 () Int (seq.len s38)) -[GOOD] (define-fun s40 () Bool (= s7 s39)) -[GOOD] (define-fun s41 () Int (- s39 s20)) -[GOOD] (define-fun s42 () (Seq Int) (seq.extract s38 s20 s41)) -[GOOD] (define-fun s43 () Int (seq.len s42)) -[GOOD] (define-fun s44 () Bool (= s7 s43)) -[GOOD] (define-fun s45 () Int (- s43 s20)) -[GOOD] (define-fun s46 () (Seq Int) (seq.extract s42 s20 s45)) -[GOOD] (define-fun s47 () Int (seq.len s46)) -[GOOD] (define-fun s48 () Bool (= s7 s47)) -[GOOD] (define-fun s49 () Int (- s47 s20)) -[GOOD] (define-fun s50 () (Seq Int) (seq.extract s46 s20 s49)) -[GOOD] (define-fun s51 () Int (seq.len s50)) -[GOOD] (define-fun s52 () Bool (= s7 s51)) -[GOOD] (define-fun s53 () Int (- s51 s20)) -[GOOD] (define-fun s54 () (Seq Int) (seq.extract s50 s20 s53)) -[GOOD] (define-fun s55 () Int (seq.len s54)) -[GOOD] (define-fun s56 () Bool (= s7 s55)) -[GOOD] (define-fun s57 () Int (seq.nth s54 s7)) -[GOOD] (define-fun s58 () Bool (< s57 s7)) -[GOOD] (define-fun s60 () Bool (> s57 s59)) -[GOOD] (define-fun s61 () Bool (or s58 s60)) -[GOOD] (define-fun s62 () Bool (not s56)) -[GOOD] (define-fun s63 () Bool (and s61 s62)) -[GOOD] (define-fun s64 () Int (seq.nth s50 s7)) -[GOOD] (define-fun s65 () Bool (< s64 s7)) -[GOOD] (define-fun s66 () Bool (> s64 s59)) -[GOOD] (define-fun s67 () Bool (or s65 s66)) -[GOOD] (define-fun s68 () Bool (or s63 s67)) -[GOOD] (define-fun s69 () Bool (not s52)) -[GOOD] (define-fun s70 () Bool (and s68 s69)) -[GOOD] (define-fun s71 () Int (seq.nth s46 s7)) -[GOOD] (define-fun s72 () Bool (< s71 s7)) -[GOOD] (define-fun s73 () Bool (> s71 s59)) -[GOOD] (define-fun s74 () Bool (or s72 s73)) -[GOOD] (define-fun s75 () Bool (or s70 s74)) -[GOOD] (define-fun s76 () Bool (not s48)) -[GOOD] (define-fun s77 () Bool (and s75 s76)) -[GOOD] (define-fun s78 () Int (seq.nth s42 s7)) -[GOOD] (define-fun s79 () Bool (< s78 s7)) -[GOOD] (define-fun s80 () Bool (> s78 s59)) -[GOOD] (define-fun s81 () Bool (or s79 s80)) -[GOOD] (define-fun s82 () Bool (or s77 s81)) -[GOOD] (define-fun s83 () Bool (not s44)) -[GOOD] (define-fun s84 () Bool (and s82 s83)) -[GOOD] (define-fun s85 () Int (seq.nth s38 s7)) -[GOOD] (define-fun s86 () Bool (< s85 s7)) -[GOOD] (define-fun s87 () Bool (> s85 s59)) -[GOOD] (define-fun s88 () Bool (or s86 s87)) -[GOOD] (define-fun s89 () Bool (or s84 s88)) -[GOOD] (define-fun s90 () Bool (not s40)) -[GOOD] (define-fun s91 () Bool (and s89 s90)) -[GOOD] (define-fun s92 () Int (seq.nth s34 s7)) -[GOOD] (define-fun s93 () Bool (< s92 s7)) -[GOOD] (define-fun s94 () Bool (> s92 s59)) -[GOOD] (define-fun s95 () Bool (or s93 s94)) -[GOOD] (define-fun s96 () Bool (or s91 s95)) -[GOOD] (define-fun s97 () Bool (not s36)) -[GOOD] (define-fun s98 () Bool (and s96 s97)) -[GOOD] (define-fun s99 () Int (seq.nth s30 s7)) -[GOOD] (define-fun s100 () Bool (< s99 s7)) -[GOOD] (define-fun s101 () Bool (> s99 s59)) -[GOOD] (define-fun s102 () Bool (or s100 s101)) -[GOOD] (define-fun s103 () Bool (or s98 s102)) -[GOOD] (define-fun s104 () Bool (not s32)) -[GOOD] (define-fun s105 () Bool (and s103 s104)) -[GOOD] (define-fun s106 () Int (seq.nth s26 s7)) -[GOOD] (define-fun s107 () Bool (< s106 s7)) -[GOOD] (define-fun s108 () Bool (> s106 s59)) -[GOOD] (define-fun s109 () Bool (or s107 s108)) -[GOOD] (define-fun s110 () Bool (or s105 s109)) -[GOOD] (define-fun s111 () Bool (not s28)) -[GOOD] (define-fun s112 () Bool (and s110 s111)) -[GOOD] (define-fun s113 () Int (seq.nth s22 s7)) -[GOOD] (define-fun s114 () Bool (< s113 s7)) -[GOOD] (define-fun s115 () Bool (> s113 s59)) -[GOOD] (define-fun s116 () Bool (or s114 s115)) -[GOOD] (define-fun s117 () Bool (or s112 s116)) -[GOOD] (define-fun s118 () Bool (not s24)) -[GOOD] (define-fun s119 () Bool (and s117 s118)) -[GOOD] (define-fun s120 () Int (seq.nth s17 s7)) -[GOOD] (define-fun s121 () Bool (< s120 s7)) -[GOOD] (define-fun s122 () Bool (> s120 s59)) -[GOOD] (define-fun s123 () Bool (or s121 s122)) -[GOOD] (define-fun s124 () Bool (or s119 s123)) -[GOOD] (define-fun s125 () Bool (not s19)) -[GOOD] (define-fun s126 () Bool (and s124 s125)) -[GOOD] ; --- delayedEqualities --- -[GOOD] ; --- formula --- -[GOOD] (assert s6) -[GOOD] (assert s12) -[GOOD] (assert s126) -[SEND] (check-sat) -[RECV] unsat -*** Solver : Z3 -*** Exit code: ExitSuccess diff --git a/SBVTestSuite/GoldFiles/mapWithFailure.gold b/SBVTestSuite/GoldFiles/mapWithFailure.gold deleted file mode 100644 --- a/SBVTestSuite/GoldFiles/mapWithFailure.gold +++ /dev/null @@ -1,184 +0,0 @@ -** 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-option :pp.max_depth 4294967295) -[GOOD] (set-option :pp.min_alias_size 4294967295) -[GOOD] (set-option :model.inline_def true ) -[GOOD] (set-logic ALL) ; has unbounded values, using catch-all. -[GOOD] ; --- uninterpreted sorts --- -[GOOD] ; --- tuples --- -[GOOD] ; --- sums --- -[GOOD] ; --- literal constants --- -[GOOD] (define-fun s2 () Int 0) -[GOOD] (define-fun s4 () (Seq Int) (as seq.empty (Seq Int))) -[GOOD] (define-fun s6 () Int 1) -[GOOD] (define-fun s91 () Int 2) -[GOOD] (define-fun s93 () Int 11) -[GOOD] (define-fun s96 () Int 10) -[GOOD] ; --- top level inputs --- -[GOOD] (declare-fun s0 () (Seq Int)) ; tracks user variable "ints" -[GOOD] ; --- constant tables --- -[GOOD] ; --- non-constant tables --- -[GOOD] ; --- uninterpreted constants --- -[GOOD] ; --- user defined functions --- -[GOOD] ; --- assignments --- -[GOOD] (define-fun s1 () Int (seq.len s0)) -[GOOD] (define-fun s3 () Bool (= s1 s2)) -[GOOD] (define-fun s5 () Int (seq.nth s0 s2)) -[GOOD] (define-fun s7 () Int (+ s5 s6)) -[GOOD] (define-fun s8 () (Seq Int) (seq.unit s7)) -[GOOD] (define-fun s9 () Int (- s1 s6)) -[GOOD] (define-fun s10 () (Seq Int) (seq.extract s0 s6 s9)) -[GOOD] (define-fun s11 () Int (seq.len s10)) -[GOOD] (define-fun s12 () Bool (= s2 s11)) -[GOOD] (define-fun s13 () Int (seq.nth s10 s2)) -[GOOD] (define-fun s14 () Int (+ s6 s13)) -[GOOD] (define-fun s15 () (Seq Int) (seq.unit s14)) -[GOOD] (define-fun s16 () Int (- s11 s6)) -[GOOD] (define-fun s17 () (Seq Int) (seq.extract s10 s6 s16)) -[GOOD] (define-fun s18 () Int (seq.len s17)) -[GOOD] (define-fun s19 () Bool (= s2 s18)) -[GOOD] (define-fun s20 () Int (seq.nth s17 s2)) -[GOOD] (define-fun s21 () Int (+ s6 s20)) -[GOOD] (define-fun s22 () (Seq Int) (seq.unit s21)) -[GOOD] (define-fun s23 () Int (- s18 s6)) -[GOOD] (define-fun s24 () (Seq Int) (seq.extract s17 s6 s23)) -[GOOD] (define-fun s25 () Int (seq.len s24)) -[GOOD] (define-fun s26 () Bool (= s2 s25)) -[GOOD] (define-fun s27 () Int (seq.nth s24 s2)) -[GOOD] (define-fun s28 () Int (+ s6 s27)) -[GOOD] (define-fun s29 () (Seq Int) (seq.unit s28)) -[GOOD] (define-fun s30 () Int (- s25 s6)) -[GOOD] (define-fun s31 () (Seq Int) (seq.extract s24 s6 s30)) -[GOOD] (define-fun s32 () Int (seq.len s31)) -[GOOD] (define-fun s33 () Bool (= s2 s32)) -[GOOD] (define-fun s34 () Int (seq.nth s31 s2)) -[GOOD] (define-fun s35 () Int (+ s6 s34)) -[GOOD] (define-fun s36 () (Seq Int) (seq.unit s35)) -[GOOD] (define-fun s37 () Int (- s32 s6)) -[GOOD] (define-fun s38 () (Seq Int) (seq.extract s31 s6 s37)) -[GOOD] (define-fun s39 () Int (seq.len s38)) -[GOOD] (define-fun s40 () Bool (= s2 s39)) -[GOOD] (define-fun s41 () Int (seq.nth s38 s2)) -[GOOD] (define-fun s42 () Int (+ s6 s41)) -[GOOD] (define-fun s43 () (Seq Int) (seq.unit s42)) -[GOOD] (define-fun s44 () Int (- s39 s6)) -[GOOD] (define-fun s45 () (Seq Int) (seq.extract s38 s6 s44)) -[GOOD] (define-fun s46 () Int (seq.len s45)) -[GOOD] (define-fun s47 () Bool (= s2 s46)) -[GOOD] (define-fun s48 () Int (seq.nth s45 s2)) -[GOOD] (define-fun s49 () Int (+ s6 s48)) -[GOOD] (define-fun s50 () (Seq Int) (seq.unit s49)) -[GOOD] (define-fun s51 () Int (- s46 s6)) -[GOOD] (define-fun s52 () (Seq Int) (seq.extract s45 s6 s51)) -[GOOD] (define-fun s53 () Int (seq.len s52)) -[GOOD] (define-fun s54 () Bool (= s2 s53)) -[GOOD] (define-fun s55 () Int (seq.nth s52 s2)) -[GOOD] (define-fun s56 () Int (+ s6 s55)) -[GOOD] (define-fun s57 () (Seq Int) (seq.unit s56)) -[GOOD] (define-fun s58 () Int (- s53 s6)) -[GOOD] (define-fun s59 () (Seq Int) (seq.extract s52 s6 s58)) -[GOOD] (define-fun s60 () Int (seq.len s59)) -[GOOD] (define-fun s61 () Bool (= s2 s60)) -[GOOD] (define-fun s62 () Int (seq.nth s59 s2)) -[GOOD] (define-fun s63 () Int (+ s6 s62)) -[GOOD] (define-fun s64 () (Seq Int) (seq.unit s63)) -[GOOD] (define-fun s65 () Int (- s60 s6)) -[GOOD] (define-fun s66 () (Seq Int) (seq.extract s59 s6 s65)) -[GOOD] (define-fun s67 () Int (seq.len s66)) -[GOOD] (define-fun s68 () Bool (= s2 s67)) -[GOOD] (define-fun s69 () Int (seq.nth s66 s2)) -[GOOD] (define-fun s70 () Int (+ s6 s69)) -[GOOD] (define-fun s71 () (Seq Int) (seq.unit s70)) -[GOOD] (define-fun s72 () (Seq Int) (ite s68 s4 s71)) -[GOOD] (define-fun s73 () (Seq Int) (seq.++ s64 s72)) -[GOOD] (define-fun s74 () (Seq Int) (ite s61 s4 s73)) -[GOOD] (define-fun s75 () (Seq Int) (seq.++ s57 s74)) -[GOOD] (define-fun s76 () (Seq Int) (ite s54 s4 s75)) -[GOOD] (define-fun s77 () (Seq Int) (seq.++ s50 s76)) -[GOOD] (define-fun s78 () (Seq Int) (ite s47 s4 s77)) -[GOOD] (define-fun s79 () (Seq Int) (seq.++ s43 s78)) -[GOOD] (define-fun s80 () (Seq Int) (ite s40 s4 s79)) -[GOOD] (define-fun s81 () (Seq Int) (seq.++ s36 s80)) -[GOOD] (define-fun s82 () (Seq Int) (ite s33 s4 s81)) -[GOOD] (define-fun s83 () (Seq Int) (seq.++ s29 s82)) -[GOOD] (define-fun s84 () (Seq Int) (ite s26 s4 s83)) -[GOOD] (define-fun s85 () (Seq Int) (seq.++ s22 s84)) -[GOOD] (define-fun s86 () (Seq Int) (ite s19 s4 s85)) -[GOOD] (define-fun s87 () (Seq Int) (seq.++ s15 s86)) -[GOOD] (define-fun s88 () (Seq Int) (ite s12 s4 s87)) -[GOOD] (define-fun s89 () (Seq Int) (seq.++ s8 s88)) -[GOOD] (define-fun s90 () (Seq Int) (ite s3 s4 s89)) -[GOOD] (define-fun s92 () Int (seq.nth s90 s91)) -[GOOD] (define-fun s94 () Bool (> s92 s93)) -[GOOD] (define-fun s95 () Bool (< s69 s2)) -[GOOD] (define-fun s97 () Bool (> s69 s96)) -[GOOD] (define-fun s98 () Bool (or s95 s97)) -[GOOD] (define-fun s99 () Bool (not s68)) -[GOOD] (define-fun s100 () Bool (and s98 s99)) -[GOOD] (define-fun s101 () Bool (< s62 s2)) -[GOOD] (define-fun s102 () Bool (> s62 s96)) -[GOOD] (define-fun s103 () Bool (or s101 s102)) -[GOOD] (define-fun s104 () Bool (or s100 s103)) -[GOOD] (define-fun s105 () Bool (not s61)) -[GOOD] (define-fun s106 () Bool (and s104 s105)) -[GOOD] (define-fun s107 () Bool (< s55 s2)) -[GOOD] (define-fun s108 () Bool (> s55 s96)) -[GOOD] (define-fun s109 () Bool (or s107 s108)) -[GOOD] (define-fun s110 () Bool (or s106 s109)) -[GOOD] (define-fun s111 () Bool (not s54)) -[GOOD] (define-fun s112 () Bool (and s110 s111)) -[GOOD] (define-fun s113 () Bool (< s48 s2)) -[GOOD] (define-fun s114 () Bool (> s48 s96)) -[GOOD] (define-fun s115 () Bool (or s113 s114)) -[GOOD] (define-fun s116 () Bool (or s112 s115)) -[GOOD] (define-fun s117 () Bool (not s47)) -[GOOD] (define-fun s118 () Bool (and s116 s117)) -[GOOD] (define-fun s119 () Bool (< s41 s2)) -[GOOD] (define-fun s120 () Bool (> s41 s96)) -[GOOD] (define-fun s121 () Bool (or s119 s120)) -[GOOD] (define-fun s122 () Bool (or s118 s121)) -[GOOD] (define-fun s123 () Bool (not s40)) -[GOOD] (define-fun s124 () Bool (and s122 s123)) -[GOOD] (define-fun s125 () Bool (< s34 s2)) -[GOOD] (define-fun s126 () Bool (> s34 s96)) -[GOOD] (define-fun s127 () Bool (or s125 s126)) -[GOOD] (define-fun s128 () Bool (or s124 s127)) -[GOOD] (define-fun s129 () Bool (not s33)) -[GOOD] (define-fun s130 () Bool (and s128 s129)) -[GOOD] (define-fun s131 () Bool (< s27 s2)) -[GOOD] (define-fun s132 () Bool (> s27 s96)) -[GOOD] (define-fun s133 () Bool (or s131 s132)) -[GOOD] (define-fun s134 () Bool (or s130 s133)) -[GOOD] (define-fun s135 () Bool (not s26)) -[GOOD] (define-fun s136 () Bool (and s134 s135)) -[GOOD] (define-fun s137 () Bool (< s20 s2)) -[GOOD] (define-fun s138 () Bool (> s20 s96)) -[GOOD] (define-fun s139 () Bool (or s137 s138)) -[GOOD] (define-fun s140 () Bool (or s136 s139)) -[GOOD] (define-fun s141 () Bool (not s19)) -[GOOD] (define-fun s142 () Bool (and s140 s141)) -[GOOD] (define-fun s143 () Bool (< s13 s2)) -[GOOD] (define-fun s144 () Bool (> s13 s96)) -[GOOD] (define-fun s145 () Bool (or s143 s144)) -[GOOD] (define-fun s146 () Bool (or s142 s145)) -[GOOD] (define-fun s147 () Bool (not s12)) -[GOOD] (define-fun s148 () Bool (and s146 s147)) -[GOOD] (define-fun s149 () Bool (< s5 s2)) -[GOOD] (define-fun s150 () Bool (> s5 s96)) -[GOOD] (define-fun s151 () Bool (or s149 s150)) -[GOOD] (define-fun s152 () Bool (or s148 s151)) -[GOOD] (define-fun s153 () Bool (not s3)) -[GOOD] (define-fun s154 () Bool (and s152 s153)) -[GOOD] (define-fun s155 () Bool (=> s94 s154)) -[GOOD] ; --- delayedEqualities --- -[GOOD] ; --- formula --- -[GOOD] (assert s155) -[SEND] (check-sat) -[RECV] sat -*** Solver : Z3 -*** Exit code: ExitSuccess diff --git a/SBVTestSuite/GoldFiles/maxlWithFailure.gold b/SBVTestSuite/GoldFiles/maxlWithFailure.gold deleted file mode 100644 --- a/SBVTestSuite/GoldFiles/maxlWithFailure.gold +++ /dev/null @@ -1,162 +0,0 @@ -** 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-option :pp.max_depth 4294967295) -[GOOD] (set-option :pp.min_alias_size 4294967295) -[GOOD] (set-option :model.inline_def true ) -[GOOD] (set-logic ALL) ; has unbounded values, using catch-all. -[GOOD] ; --- uninterpreted sorts --- -[GOOD] ; --- tuples --- -[GOOD] ; --- sums --- -[GOOD] ; --- literal constants --- -[GOOD] (define-fun s2 () Int 0) -[GOOD] (define-fun s4 () Int 1) -[GOOD] (define-fun s81 () Int 10) -[GOOD] ; --- top level inputs --- -[GOOD] (declare-fun s0 () (Seq Int)) ; tracks user variable "ints" -[GOOD] ; --- constant tables --- -[GOOD] ; --- non-constant tables --- -[GOOD] ; --- uninterpreted constants --- -[GOOD] ; --- user defined functions --- -[GOOD] ; --- assignments --- -[GOOD] (define-fun s1 () Int (seq.len s0)) -[GOOD] (define-fun s3 () Bool (= s1 s2)) -[GOOD] (define-fun s5 () Int (- s1 s4)) -[GOOD] (define-fun s6 () (Seq Int) (seq.extract s0 s4 s5)) -[GOOD] (define-fun s7 () Int (seq.len s6)) -[GOOD] (define-fun s8 () Bool (= s2 s7)) -[GOOD] (define-fun s9 () Int (seq.nth s0 s2)) -[GOOD] (define-fun s10 () Bool (<= s9 s2)) -[GOOD] (define-fun s11 () Int (ite s10 s2 s9)) -[GOOD] (define-fun s12 () Int (- s7 s4)) -[GOOD] (define-fun s13 () (Seq Int) (seq.extract s6 s4 s12)) -[GOOD] (define-fun s14 () Int (seq.len s13)) -[GOOD] (define-fun s15 () Bool (= s2 s14)) -[GOOD] (define-fun s16 () Int (seq.nth s6 s2)) -[GOOD] (define-fun s17 () Bool (<= s16 s11)) -[GOOD] (define-fun s18 () Int (ite s17 s11 s16)) -[GOOD] (define-fun s19 () Int (- s14 s4)) -[GOOD] (define-fun s20 () (Seq Int) (seq.extract s13 s4 s19)) -[GOOD] (define-fun s21 () Int (seq.len s20)) -[GOOD] (define-fun s22 () Bool (= s2 s21)) -[GOOD] (define-fun s23 () Int (seq.nth s13 s2)) -[GOOD] (define-fun s24 () Bool (<= s23 s18)) -[GOOD] (define-fun s25 () Int (ite s24 s18 s23)) -[GOOD] (define-fun s26 () Int (- s21 s4)) -[GOOD] (define-fun s27 () (Seq Int) (seq.extract s20 s4 s26)) -[GOOD] (define-fun s28 () Int (seq.len s27)) -[GOOD] (define-fun s29 () Bool (= s2 s28)) -[GOOD] (define-fun s30 () Int (seq.nth s20 s2)) -[GOOD] (define-fun s31 () Bool (<= s30 s25)) -[GOOD] (define-fun s32 () Int (ite s31 s25 s30)) -[GOOD] (define-fun s33 () Int (- s28 s4)) -[GOOD] (define-fun s34 () (Seq Int) (seq.extract s27 s4 s33)) -[GOOD] (define-fun s35 () Int (seq.len s34)) -[GOOD] (define-fun s36 () Bool (= s2 s35)) -[GOOD] (define-fun s37 () Int (seq.nth s27 s2)) -[GOOD] (define-fun s38 () Bool (<= s37 s32)) -[GOOD] (define-fun s39 () Int (ite s38 s32 s37)) -[GOOD] (define-fun s40 () Int (- s35 s4)) -[GOOD] (define-fun s41 () (Seq Int) (seq.extract s34 s4 s40)) -[GOOD] (define-fun s42 () Int (seq.len s41)) -[GOOD] (define-fun s43 () Bool (= s2 s42)) -[GOOD] (define-fun s44 () Int (seq.nth s34 s2)) -[GOOD] (define-fun s45 () Bool (<= s44 s39)) -[GOOD] (define-fun s46 () Int (ite s45 s39 s44)) -[GOOD] (define-fun s47 () Int (- s42 s4)) -[GOOD] (define-fun s48 () (Seq Int) (seq.extract s41 s4 s47)) -[GOOD] (define-fun s49 () Int (seq.len s48)) -[GOOD] (define-fun s50 () Bool (= s2 s49)) -[GOOD] (define-fun s51 () Int (seq.nth s41 s2)) -[GOOD] (define-fun s52 () Bool (<= s51 s46)) -[GOOD] (define-fun s53 () Int (ite s52 s46 s51)) -[GOOD] (define-fun s54 () Int (- s49 s4)) -[GOOD] (define-fun s55 () (Seq Int) (seq.extract s48 s4 s54)) -[GOOD] (define-fun s56 () Int (seq.len s55)) -[GOOD] (define-fun s57 () Bool (= s2 s56)) -[GOOD] (define-fun s58 () Int (seq.nth s48 s2)) -[GOOD] (define-fun s59 () Bool (<= s58 s53)) -[GOOD] (define-fun s60 () Int (ite s59 s53 s58)) -[GOOD] (define-fun s61 () Int (- s56 s4)) -[GOOD] (define-fun s62 () (Seq Int) (seq.extract s55 s4 s61)) -[GOOD] (define-fun s63 () Int (seq.len s62)) -[GOOD] (define-fun s64 () Bool (= s2 s63)) -[GOOD] (define-fun s65 () Int (seq.nth s55 s2)) -[GOOD] (define-fun s66 () Bool (<= s65 s60)) -[GOOD] (define-fun s67 () Int (ite s66 s60 s65)) -[GOOD] (define-fun s68 () Int (seq.nth s62 s2)) -[GOOD] (define-fun s69 () Bool (<= s68 s67)) -[GOOD] (define-fun s70 () Int (ite s69 s67 s68)) -[GOOD] (define-fun s71 () Int (ite s64 s67 s70)) -[GOOD] (define-fun s72 () Int (ite s57 s60 s71)) -[GOOD] (define-fun s73 () Int (ite s50 s53 s72)) -[GOOD] (define-fun s74 () Int (ite s43 s46 s73)) -[GOOD] (define-fun s75 () Int (ite s36 s39 s74)) -[GOOD] (define-fun s76 () Int (ite s29 s32 s75)) -[GOOD] (define-fun s77 () Int (ite s22 s25 s76)) -[GOOD] (define-fun s78 () Int (ite s15 s18 s77)) -[GOOD] (define-fun s79 () Int (ite s8 s11 s78)) -[GOOD] (define-fun s80 () Int (ite s3 s2 s79)) -[GOOD] (define-fun s82 () Bool (> s80 s81)) -[GOOD] (define-fun s83 () Bool (< s9 s2)) -[GOOD] (define-fun s84 () Bool (> s9 s81)) -[GOOD] (define-fun s85 () Bool (or s83 s84)) -[GOOD] (define-fun s86 () Bool (< s16 s2)) -[GOOD] (define-fun s87 () Bool (> s16 s81)) -[GOOD] (define-fun s88 () Bool (or s86 s87)) -[GOOD] (define-fun s89 () Bool (or s85 s88)) -[GOOD] (define-fun s90 () Bool (< s23 s2)) -[GOOD] (define-fun s91 () Bool (> s23 s81)) -[GOOD] (define-fun s92 () Bool (or s90 s91)) -[GOOD] (define-fun s93 () Bool (or s89 s92)) -[GOOD] (define-fun s94 () Bool (< s30 s2)) -[GOOD] (define-fun s95 () Bool (> s30 s81)) -[GOOD] (define-fun s96 () Bool (or s94 s95)) -[GOOD] (define-fun s97 () Bool (or s93 s96)) -[GOOD] (define-fun s98 () Bool (< s37 s2)) -[GOOD] (define-fun s99 () Bool (> s37 s81)) -[GOOD] (define-fun s100 () Bool (or s98 s99)) -[GOOD] (define-fun s101 () Bool (or s97 s100)) -[GOOD] (define-fun s102 () Bool (< s44 s2)) -[GOOD] (define-fun s103 () Bool (> s44 s81)) -[GOOD] (define-fun s104 () Bool (or s102 s103)) -[GOOD] (define-fun s105 () Bool (or s101 s104)) -[GOOD] (define-fun s106 () Bool (< s51 s2)) -[GOOD] (define-fun s107 () Bool (> s51 s81)) -[GOOD] (define-fun s108 () Bool (or s106 s107)) -[GOOD] (define-fun s109 () Bool (or s105 s108)) -[GOOD] (define-fun s110 () Bool (< s58 s2)) -[GOOD] (define-fun s111 () Bool (> s58 s81)) -[GOOD] (define-fun s112 () Bool (or s110 s111)) -[GOOD] (define-fun s113 () Bool (or s109 s112)) -[GOOD] (define-fun s114 () Bool (< s65 s2)) -[GOOD] (define-fun s115 () Bool (> s65 s81)) -[GOOD] (define-fun s116 () Bool (or s114 s115)) -[GOOD] (define-fun s117 () Bool (or s113 s116)) -[GOOD] (define-fun s118 () Bool (< s68 s2)) -[GOOD] (define-fun s119 () Bool (> s68 s81)) -[GOOD] (define-fun s120 () Bool (or s118 s119)) -[GOOD] (define-fun s121 () Bool (or s117 s120)) -[GOOD] (define-fun s122 () Bool (ite s64 s117 s121)) -[GOOD] (define-fun s123 () Bool (ite s57 s113 s122)) -[GOOD] (define-fun s124 () Bool (ite s50 s109 s123)) -[GOOD] (define-fun s125 () Bool (ite s43 s105 s124)) -[GOOD] (define-fun s126 () Bool (ite s36 s101 s125)) -[GOOD] (define-fun s127 () Bool (ite s29 s97 s126)) -[GOOD] (define-fun s128 () Bool (ite s22 s93 s127)) -[GOOD] (define-fun s129 () Bool (ite s15 s89 s128)) -[GOOD] (define-fun s130 () Bool (ite s8 s85 s129)) -[GOOD] (define-fun s131 () Bool (not s3)) -[GOOD] (define-fun s132 () Bool (and s130 s131)) -[GOOD] (define-fun s133 () Bool (=> s82 s132)) -[GOOD] ; --- delayedEqualities --- -[GOOD] ; --- formula --- -[GOOD] (assert s133) -[SEND] (check-sat) -[RECV] sat -*** Solver : Z3 -*** Exit code: ExitSuccess diff --git a/SBVTestSuite/GoldFiles/maxrWithFailure.gold b/SBVTestSuite/GoldFiles/maxrWithFailure.gold deleted file mode 100644 --- a/SBVTestSuite/GoldFiles/maxrWithFailure.gold +++ /dev/null @@ -1,171 +0,0 @@ -** 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-option :pp.max_depth 4294967295) -[GOOD] (set-option :pp.min_alias_size 4294967295) -[GOOD] (set-option :model.inline_def true ) -[GOOD] (set-logic ALL) ; has unbounded values, using catch-all. -[GOOD] ; --- uninterpreted sorts --- -[GOOD] ; --- tuples --- -[GOOD] ; --- sums --- -[GOOD] ; --- literal constants --- -[GOOD] (define-fun s2 () Int 0) -[GOOD] (define-fun s5 () Int 1) -[GOOD] (define-fun s81 () Int 10) -[GOOD] ; --- top level inputs --- -[GOOD] (declare-fun s0 () (Seq Int)) ; tracks user variable "ints" -[GOOD] ; --- constant tables --- -[GOOD] ; --- non-constant tables --- -[GOOD] ; --- uninterpreted constants --- -[GOOD] ; --- user defined functions --- -[GOOD] ; --- assignments --- -[GOOD] (define-fun s1 () Int (seq.len s0)) -[GOOD] (define-fun s3 () Bool (= s1 s2)) -[GOOD] (define-fun s4 () Int (seq.nth s0 s2)) -[GOOD] (define-fun s6 () Int (- s1 s5)) -[GOOD] (define-fun s7 () (Seq Int) (seq.extract s0 s5 s6)) -[GOOD] (define-fun s8 () Int (seq.len s7)) -[GOOD] (define-fun s9 () Bool (= s2 s8)) -[GOOD] (define-fun s10 () Int (seq.nth s7 s2)) -[GOOD] (define-fun s11 () Int (- s8 s5)) -[GOOD] (define-fun s12 () (Seq Int) (seq.extract s7 s5 s11)) -[GOOD] (define-fun s13 () Int (seq.len s12)) -[GOOD] (define-fun s14 () Bool (= s2 s13)) -[GOOD] (define-fun s15 () Int (seq.nth s12 s2)) -[GOOD] (define-fun s16 () Int (- s13 s5)) -[GOOD] (define-fun s17 () (Seq Int) (seq.extract s12 s5 s16)) -[GOOD] (define-fun s18 () Int (seq.len s17)) -[GOOD] (define-fun s19 () Bool (= s2 s18)) -[GOOD] (define-fun s20 () Int (seq.nth s17 s2)) -[GOOD] (define-fun s21 () Int (- s18 s5)) -[GOOD] (define-fun s22 () (Seq Int) (seq.extract s17 s5 s21)) -[GOOD] (define-fun s23 () Int (seq.len s22)) -[GOOD] (define-fun s24 () Bool (= s2 s23)) -[GOOD] (define-fun s25 () Int (seq.nth s22 s2)) -[GOOD] (define-fun s26 () Int (- s23 s5)) -[GOOD] (define-fun s27 () (Seq Int) (seq.extract s22 s5 s26)) -[GOOD] (define-fun s28 () Int (seq.len s27)) -[GOOD] (define-fun s29 () Bool (= s2 s28)) -[GOOD] (define-fun s30 () Int (seq.nth s27 s2)) -[GOOD] (define-fun s31 () Int (- s28 s5)) -[GOOD] (define-fun s32 () (Seq Int) (seq.extract s27 s5 s31)) -[GOOD] (define-fun s33 () Int (seq.len s32)) -[GOOD] (define-fun s34 () Bool (= s2 s33)) -[GOOD] (define-fun s35 () Int (seq.nth s32 s2)) -[GOOD] (define-fun s36 () Int (- s33 s5)) -[GOOD] (define-fun s37 () (Seq Int) (seq.extract s32 s5 s36)) -[GOOD] (define-fun s38 () Int (seq.len s37)) -[GOOD] (define-fun s39 () Bool (= s2 s38)) -[GOOD] (define-fun s40 () Int (seq.nth s37 s2)) -[GOOD] (define-fun s41 () Int (- s38 s5)) -[GOOD] (define-fun s42 () (Seq Int) (seq.extract s37 s5 s41)) -[GOOD] (define-fun s43 () Int (seq.len s42)) -[GOOD] (define-fun s44 () Bool (= s2 s43)) -[GOOD] (define-fun s45 () Int (seq.nth s42 s2)) -[GOOD] (define-fun s46 () Int (- s43 s5)) -[GOOD] (define-fun s47 () (Seq Int) (seq.extract s42 s5 s46)) -[GOOD] (define-fun s48 () Int (seq.len s47)) -[GOOD] (define-fun s49 () Bool (= s2 s48)) -[GOOD] (define-fun s50 () Int (seq.nth s47 s2)) -[GOOD] (define-fun s51 () Bool (<= s50 s2)) -[GOOD] (define-fun s52 () Int (ite s51 s2 s50)) -[GOOD] (define-fun s53 () Int (ite s49 s2 s52)) -[GOOD] (define-fun s54 () Bool (<= s45 s53)) -[GOOD] (define-fun s55 () Int (ite s54 s53 s45)) -[GOOD] (define-fun s56 () Int (ite s44 s2 s55)) -[GOOD] (define-fun s57 () Bool (<= s40 s56)) -[GOOD] (define-fun s58 () Int (ite s57 s56 s40)) -[GOOD] (define-fun s59 () Int (ite s39 s2 s58)) -[GOOD] (define-fun s60 () Bool (<= s35 s59)) -[GOOD] (define-fun s61 () Int (ite s60 s59 s35)) -[GOOD] (define-fun s62 () Int (ite s34 s2 s61)) -[GOOD] (define-fun s63 () Bool (<= s30 s62)) -[GOOD] (define-fun s64 () Int (ite s63 s62 s30)) -[GOOD] (define-fun s65 () Int (ite s29 s2 s64)) -[GOOD] (define-fun s66 () Bool (<= s25 s65)) -[GOOD] (define-fun s67 () Int (ite s66 s65 s25)) -[GOOD] (define-fun s68 () Int (ite s24 s2 s67)) -[GOOD] (define-fun s69 () Bool (<= s20 s68)) -[GOOD] (define-fun s70 () Int (ite s69 s68 s20)) -[GOOD] (define-fun s71 () Int (ite s19 s2 s70)) -[GOOD] (define-fun s72 () Bool (<= s15 s71)) -[GOOD] (define-fun s73 () Int (ite s72 s71 s15)) -[GOOD] (define-fun s74 () Int (ite s14 s2 s73)) -[GOOD] (define-fun s75 () Bool (<= s10 s74)) -[GOOD] (define-fun s76 () Int (ite s75 s74 s10)) -[GOOD] (define-fun s77 () Int (ite s9 s2 s76)) -[GOOD] (define-fun s78 () Bool (<= s4 s77)) -[GOOD] (define-fun s79 () Int (ite s78 s77 s4)) -[GOOD] (define-fun s80 () Int (ite s3 s2 s79)) -[GOOD] (define-fun s82 () Bool (> s80 s81)) -[GOOD] (define-fun s83 () Bool (< s50 s2)) -[GOOD] (define-fun s84 () Bool (> s50 s81)) -[GOOD] (define-fun s85 () Bool (or s83 s84)) -[GOOD] (define-fun s86 () Bool (not s49)) -[GOOD] (define-fun s87 () Bool (and s85 s86)) -[GOOD] (define-fun s88 () Bool (< s45 s2)) -[GOOD] (define-fun s89 () Bool (> s45 s81)) -[GOOD] (define-fun s90 () Bool (or s88 s89)) -[GOOD] (define-fun s91 () Bool (or s87 s90)) -[GOOD] (define-fun s92 () Bool (not s44)) -[GOOD] (define-fun s93 () Bool (and s91 s92)) -[GOOD] (define-fun s94 () Bool (< s40 s2)) -[GOOD] (define-fun s95 () Bool (> s40 s81)) -[GOOD] (define-fun s96 () Bool (or s94 s95)) -[GOOD] (define-fun s97 () Bool (or s93 s96)) -[GOOD] (define-fun s98 () Bool (not s39)) -[GOOD] (define-fun s99 () Bool (and s97 s98)) -[GOOD] (define-fun s100 () Bool (< s35 s2)) -[GOOD] (define-fun s101 () Bool (> s35 s81)) -[GOOD] (define-fun s102 () Bool (or s100 s101)) -[GOOD] (define-fun s103 () Bool (or s99 s102)) -[GOOD] (define-fun s104 () Bool (not s34)) -[GOOD] (define-fun s105 () Bool (and s103 s104)) -[GOOD] (define-fun s106 () Bool (< s30 s2)) -[GOOD] (define-fun s107 () Bool (> s30 s81)) -[GOOD] (define-fun s108 () Bool (or s106 s107)) -[GOOD] (define-fun s109 () Bool (or s105 s108)) -[GOOD] (define-fun s110 () Bool (not s29)) -[GOOD] (define-fun s111 () Bool (and s109 s110)) -[GOOD] (define-fun s112 () Bool (< s25 s2)) -[GOOD] (define-fun s113 () Bool (> s25 s81)) -[GOOD] (define-fun s114 () Bool (or s112 s113)) -[GOOD] (define-fun s115 () Bool (or s111 s114)) -[GOOD] (define-fun s116 () Bool (not s24)) -[GOOD] (define-fun s117 () Bool (and s115 s116)) -[GOOD] (define-fun s118 () Bool (< s20 s2)) -[GOOD] (define-fun s119 () Bool (> s20 s81)) -[GOOD] (define-fun s120 () Bool (or s118 s119)) -[GOOD] (define-fun s121 () Bool (or s117 s120)) -[GOOD] (define-fun s122 () Bool (not s19)) -[GOOD] (define-fun s123 () Bool (and s121 s122)) -[GOOD] (define-fun s124 () Bool (< s15 s2)) -[GOOD] (define-fun s125 () Bool (> s15 s81)) -[GOOD] (define-fun s126 () Bool (or s124 s125)) -[GOOD] (define-fun s127 () Bool (or s123 s126)) -[GOOD] (define-fun s128 () Bool (not s14)) -[GOOD] (define-fun s129 () Bool (and s127 s128)) -[GOOD] (define-fun s130 () Bool (< s10 s2)) -[GOOD] (define-fun s131 () Bool (> s10 s81)) -[GOOD] (define-fun s132 () Bool (or s130 s131)) -[GOOD] (define-fun s133 () Bool (or s129 s132)) -[GOOD] (define-fun s134 () Bool (not s9)) -[GOOD] (define-fun s135 () Bool (and s133 s134)) -[GOOD] (define-fun s136 () Bool (< s4 s2)) -[GOOD] (define-fun s137 () Bool (> s4 s81)) -[GOOD] (define-fun s138 () Bool (or s136 s137)) -[GOOD] (define-fun s139 () Bool (or s135 s138)) -[GOOD] (define-fun s140 () Bool (not s3)) -[GOOD] (define-fun s141 () Bool (and s139 s140)) -[GOOD] (define-fun s142 () Bool (=> s82 s141)) -[GOOD] ; --- delayedEqualities --- -[GOOD] ; --- formula --- -[GOOD] (assert s142) -[SEND] (check-sat) -[RECV] sat -*** Solver : Z3 -*** Exit code: ExitSuccess diff --git a/SBVTestSuite/GoldFiles/nested1.gold b/SBVTestSuite/GoldFiles/nested1.gold --- a/SBVTestSuite/GoldFiles/nested1.gold +++ b/SBVTestSuite/GoldFiles/nested1.gold @@ -9,6 +9,3 @@ *** while another one is in execution, or use results from one such call in another. *** Please avoid such nested calls, all interactions should be from the same context. *** See https://github.com/LeventErkok/sbv/issues/71 for several examples. - -CallStack (from HasCallStack): - error, called at ./Data/SBV/Core/Symbolic.hs:1896:48 in sbv-11.0-inplace:Data.SBV.Core.Symbolic diff --git a/SBVTestSuite/GoldFiles/nested2.gold b/SBVTestSuite/GoldFiles/nested2.gold --- a/SBVTestSuite/GoldFiles/nested2.gold +++ b/SBVTestSuite/GoldFiles/nested2.gold @@ -9,6 +9,3 @@ *** while another one is in execution, or use results from one such call in another. *** Please avoid such nested calls, all interactions should be from the same context. *** See https://github.com/LeventErkok/sbv/issues/71 for several examples. - -CallStack (from HasCallStack): - error, called at ./Data/SBV/Core/Symbolic.hs:1896:48 in sbv-11.0-inplace:Data.SBV.Core.Symbolic diff --git a/SBVTestSuite/GoldFiles/nested3.gold b/SBVTestSuite/GoldFiles/nested3.gold --- a/SBVTestSuite/GoldFiles/nested3.gold +++ b/SBVTestSuite/GoldFiles/nested3.gold @@ -32,6 +32,3 @@ *** while another one is in execution, or use results from one such call in another. *** Please avoid such nested calls, all interactions should be from the same context. *** See https://github.com/LeventErkok/sbv/issues/71 for several examples. - -CallStack (from HasCallStack): - error, called at ./Data/SBV/Core/Symbolic.hs:1896:48 in sbv-11.0-inplace:Data.SBV.Core.Symbolic diff --git a/SBVTestSuite/GoldFiles/nested4.gold b/SBVTestSuite/GoldFiles/nested4.gold --- a/SBVTestSuite/GoldFiles/nested4.gold +++ b/SBVTestSuite/GoldFiles/nested4.gold @@ -9,6 +9,3 @@ *** while another one is in execution, or use results from one such call in another. *** Please avoid such nested calls, all interactions should be from the same context. *** See https://github.com/LeventErkok/sbv/issues/71 for several examples. - -CallStack (from HasCallStack): - error, called at ./Data/SBV/Core/Symbolic.hs:1896:48 in sbv-11.0-inplace:Data.SBV.Core.Symbolic diff --git a/SBVTestSuite/GoldFiles/noOpt1.gold b/SBVTestSuite/GoldFiles/noOpt1.gold --- a/SBVTestSuite/GoldFiles/noOpt1.gold +++ b/SBVTestSuite/GoldFiles/noOpt1.gold @@ -26,6 +26,3 @@ *** Data.SBV: Unsupported call to optimize when no objectives are present. *** Use "sat" for plain satisfaction - -CallStack (from HasCallStack): - error, called at ./Data/SBV/Provers/Prover.hs:264:27 in sbv-11.0-inplace:Data.SBV.Provers.Prover diff --git a/SBVTestSuite/GoldFiles/noOpt2.gold b/SBVTestSuite/GoldFiles/noOpt2.gold --- a/SBVTestSuite/GoldFiles/noOpt2.gold +++ b/SBVTestSuite/GoldFiles/noOpt2.gold @@ -28,6 +28,3 @@ *** Data.SBV: Unsupported call sat/prove when optimization objectives are present. *** Use "optimize"/"optimizeWith" to calculate optimal satisfaction! - -CallStack (from HasCallStack): - error, called at ./Data/SBV/Provers/Prover.hs:611:33 in sbv-11.0-inplace:Data.SBV.Provers.Prover diff --git a/SBVTestSuite/GoldFiles/optBasicsRange_08_signed_max.gold b/SBVTestSuite/GoldFiles/optBasicsRange_08_signed_max.gold --- a/SBVTestSuite/GoldFiles/optBasicsRange_08_signed_max.gold +++ b/SBVTestSuite/GoldFiles/optBasicsRange_08_signed_max.gold @@ -1,4 +1,4 @@ Optimal model: - m = 127 :: Int8 x = 127 :: Int8 toMetricSpace(m) = 255 :: Word8 + m = 127 :: Int8 diff --git a/SBVTestSuite/GoldFiles/optBasicsRange_08_signed_min.gold b/SBVTestSuite/GoldFiles/optBasicsRange_08_signed_min.gold --- a/SBVTestSuite/GoldFiles/optBasicsRange_08_signed_min.gold +++ b/SBVTestSuite/GoldFiles/optBasicsRange_08_signed_min.gold @@ -1,4 +1,4 @@ Optimal model: - m = -128 :: Int8 x = -128 :: Int8 toMetricSpace(m) = 0 :: Word8 + m = -128 :: Int8 diff --git a/SBVTestSuite/GoldFiles/optBasicsRange_16_signed_max.gold b/SBVTestSuite/GoldFiles/optBasicsRange_16_signed_max.gold --- a/SBVTestSuite/GoldFiles/optBasicsRange_16_signed_max.gold +++ b/SBVTestSuite/GoldFiles/optBasicsRange_16_signed_max.gold @@ -1,4 +1,4 @@ Optimal model: - m = 32767 :: Int16 x = 32767 :: Int16 toMetricSpace(m) = 65535 :: Word16 + m = 32767 :: Int16 diff --git a/SBVTestSuite/GoldFiles/optBasicsRange_16_signed_min.gold b/SBVTestSuite/GoldFiles/optBasicsRange_16_signed_min.gold --- a/SBVTestSuite/GoldFiles/optBasicsRange_16_signed_min.gold +++ b/SBVTestSuite/GoldFiles/optBasicsRange_16_signed_min.gold @@ -1,4 +1,4 @@ Optimal model: - m = -32768 :: Int16 x = -32768 :: Int16 toMetricSpace(m) = 0 :: Word16 + m = -32768 :: Int16 diff --git a/SBVTestSuite/GoldFiles/optBasicsRange_32_signed_max.gold b/SBVTestSuite/GoldFiles/optBasicsRange_32_signed_max.gold --- a/SBVTestSuite/GoldFiles/optBasicsRange_32_signed_max.gold +++ b/SBVTestSuite/GoldFiles/optBasicsRange_32_signed_max.gold @@ -1,4 +1,4 @@ Optimal model: - m = 2147483647 :: Int32 x = 2147483647 :: Int32 toMetricSpace(m) = 4294967295 :: Word32 + m = 2147483647 :: Int32 diff --git a/SBVTestSuite/GoldFiles/optBasicsRange_32_signed_min.gold b/SBVTestSuite/GoldFiles/optBasicsRange_32_signed_min.gold --- a/SBVTestSuite/GoldFiles/optBasicsRange_32_signed_min.gold +++ b/SBVTestSuite/GoldFiles/optBasicsRange_32_signed_min.gold @@ -1,4 +1,4 @@ Optimal model: - m = -2147483648 :: Int32 x = -2147483648 :: Int32 toMetricSpace(m) = 0 :: Word32 + m = -2147483648 :: Int32 diff --git a/SBVTestSuite/GoldFiles/optBasicsRange_64_signed_max.gold b/SBVTestSuite/GoldFiles/optBasicsRange_64_signed_max.gold --- a/SBVTestSuite/GoldFiles/optBasicsRange_64_signed_max.gold +++ b/SBVTestSuite/GoldFiles/optBasicsRange_64_signed_max.gold @@ -1,4 +1,4 @@ Optimal model: - m = 9223372036854775807 :: Int64 x = 9223372036854775807 :: Int64 toMetricSpace(m) = 18446744073709551615 :: Word64 + m = 9223372036854775807 :: Int64 diff --git a/SBVTestSuite/GoldFiles/optBasicsRange_64_signed_min.gold b/SBVTestSuite/GoldFiles/optBasicsRange_64_signed_min.gold --- a/SBVTestSuite/GoldFiles/optBasicsRange_64_signed_min.gold +++ b/SBVTestSuite/GoldFiles/optBasicsRange_64_signed_min.gold @@ -1,4 +1,4 @@ Optimal model: - m = -9223372036854775808 :: Int64 x = -9223372036854775808 :: Int64 toMetricSpace(m) = 0 :: Word64 + m = -9223372036854775808 :: Int64 diff --git a/SBVTestSuite/GoldFiles/optFloat1a.gold b/SBVTestSuite/GoldFiles/optFloat1a.gold --- a/SBVTestSuite/GoldFiles/optFloat1a.gold +++ b/SBVTestSuite/GoldFiles/optFloat1a.gold @@ -1,5 +1,5 @@ Optimal model: - min-x = -3.4028235e38 :: Float + x = -3.4028235e38 :: Float 3 2 1 0 1 09876543 21098765432109876543210 S ---E8--- ----------S23---------- @@ -13,7 +13,17 @@ Octal: -0o3.77777774p+126 Decimal: -3.4028235e38 Hex: -0xf.fffffp+124 - x = -3.4028235e38 :: Float + toMetricSpace(min-x) = 8388608 :: Word32 + 3 2 1 0 + 1098 7654 3210 9876 5432 1098 7654 3210 + Binary layout: 0000 0000 1000 0000 0000 0000 0000 0000 + Hex layout: 0080 0000 + Type: Unsigned 32-bit word + Binary: 0b100000000000000000000000 + Octal: 0o40000000 + Decimal: 8388608 + Hex: 0x800000 + min-x = -3.4028235e38 :: Float 3 2 1 0 1 09876543 21098765432109876543210 S ---E8--- ----------S23---------- @@ -27,13 +37,3 @@ Octal: -0o3.77777774p+126 Decimal: -3.4028235e38 Hex: -0xf.fffffp+124 - toMetricSpace(min-x) = 8388608 :: Word32 - 3 2 1 0 - 1098 7654 3210 9876 5432 1098 7654 3210 - Binary layout: 0000 0000 1000 0000 0000 0000 0000 0000 - Hex layout: 0080 0000 - Type: Unsigned 32-bit word - Binary: 0b100000000000000000000000 - Octal: 0o40000000 - Decimal: 8388608 - Hex: 0x800000 diff --git a/SBVTestSuite/GoldFiles/optFloat1b.gold b/SBVTestSuite/GoldFiles/optFloat1b.gold --- a/SBVTestSuite/GoldFiles/optFloat1b.gold +++ b/SBVTestSuite/GoldFiles/optFloat1b.gold @@ -1,15 +1,4 @@ Optimal model: - min-x = -Infinity :: Float - 3 2 1 0 - 1 09876543 21098765432109876543210 - S ---E8--- ----------S23---------- - Binary layout: 1 11111111 00000000000000000000000 - Hex layout: FF80 0000 - Precision: Single - Sign: Negative - Exponent: 128 (Stored: 255, Bias: 127) - Classification: FP_INFINITE - Value: -Infinity x = -Infinity :: Float 3 2 1 0 1 09876543 21098765432109876543210 @@ -31,3 +20,14 @@ Octal: 0o37777777 Decimal: 8388607 Hex: 0x7fffff + min-x = -Infinity :: Float + 3 2 1 0 + 1 09876543 21098765432109876543210 + S ---E8--- ----------S23---------- + Binary layout: 1 11111111 00000000000000000000000 + Hex layout: FF80 0000 + Precision: Single + Sign: Negative + Exponent: 128 (Stored: 255, Bias: 127) + Classification: FP_INFINITE + Value: -Infinity diff --git a/SBVTestSuite/GoldFiles/optFloat1c.gold b/SBVTestSuite/GoldFiles/optFloat1c.gold --- a/SBVTestSuite/GoldFiles/optFloat1c.gold +++ b/SBVTestSuite/GoldFiles/optFloat1c.gold @@ -1,5 +1,5 @@ Optimal model: - max-x = 3.4028235e38 :: Float + x = 3.4028235e38 :: Float 3 2 1 0 1 09876543 21098765432109876543210 S ---E8--- ----------S23---------- @@ -13,7 +13,17 @@ Octal: 0o3.77777774p+126 Decimal: 3.4028235e38 Hex: 0xf.fffffp+124 - x = 3.4028235e38 :: Float + toMetricSpace(max-x) = 4286578687 :: Word32 + 3 2 1 0 + 1098 7654 3210 9876 5432 1098 7654 3210 + Binary layout: 1111 1111 0111 1111 1111 1111 1111 1111 + Hex layout: FF7F FFFF + Type: Unsigned 32-bit word + Binary: 0b11111111011111111111111111111111 + Octal: 0o37737777777 + Decimal: 4286578687 + Hex: 0xff7fffff + max-x = 3.4028235e38 :: Float 3 2 1 0 1 09876543 21098765432109876543210 S ---E8--- ----------S23---------- @@ -27,13 +37,3 @@ Octal: 0o3.77777774p+126 Decimal: 3.4028235e38 Hex: 0xf.fffffp+124 - toMetricSpace(max-x) = 4286578687 :: Word32 - 3 2 1 0 - 1098 7654 3210 9876 5432 1098 7654 3210 - Binary layout: 1111 1111 0111 1111 1111 1111 1111 1111 - Hex layout: FF7F FFFF - Type: Unsigned 32-bit word - Binary: 0b11111111011111111111111111111111 - Octal: 0o37737777777 - Decimal: 4286578687 - Hex: 0xff7fffff diff --git a/SBVTestSuite/GoldFiles/optFloat1d.gold b/SBVTestSuite/GoldFiles/optFloat1d.gold --- a/SBVTestSuite/GoldFiles/optFloat1d.gold +++ b/SBVTestSuite/GoldFiles/optFloat1d.gold @@ -1,15 +1,4 @@ Optimal model: - max-y = Infinity :: Float - 3 2 1 0 - 1 09876543 21098765432109876543210 - S ---E8--- ----------S23---------- - Binary layout: 0 11111111 00000000000000000000000 - Hex layout: 7F80 0000 - Precision: Single - Sign: Positive - Exponent: 128 (Stored: 255, Bias: 127) - Classification: FP_INFINITE - Value: Infinity x = Infinity :: Float 3 2 1 0 1 09876543 21098765432109876543210 @@ -31,3 +20,14 @@ Octal: 0o37740000000 Decimal: 4286578688 Hex: 0xff800000 + max-y = Infinity :: Float + 3 2 1 0 + 1 09876543 21098765432109876543210 + S ---E8--- ----------S23---------- + Binary layout: 0 11111111 00000000000000000000000 + Hex layout: 7F80 0000 + Precision: Single + Sign: Positive + Exponent: 128 (Stored: 255, Bias: 127) + Classification: FP_INFINITE + Value: Infinity diff --git a/SBVTestSuite/GoldFiles/optFloat2a.gold b/SBVTestSuite/GoldFiles/optFloat2a.gold --- a/SBVTestSuite/GoldFiles/optFloat2a.gold +++ b/SBVTestSuite/GoldFiles/optFloat2a.gold @@ -1,5 +1,5 @@ Optimal model: - min-x = -1.7976931348623157e308 :: Double + x = -1.7976931348623157e308 :: Double 6 5 4 3 2 1 0 3 21098765432 1098765432109876543210987654321098765432109876543210 S ----E11---- ------------------------S52------------------------- @@ -13,7 +13,17 @@ Octal: -0o1.777777777777777774p+1023 Decimal: -1.7976931348623157e308 Hex: -0xf.ffffffffffff8p+1020 - x = -1.7976931348623157e308 :: Double + toMetricSpace(min-x) = 4503599627370496 :: Word64 + 6 5 4 3 2 1 0 + 3210 9876 5432 1098 7654 3210 9876 5432 1098 7654 3210 9876 5432 1098 7654 3210 + Binary layout: 0000 0000 0001 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 + Hex layout: 0010 0000 0000 0000 + Type: Unsigned 64-bit word + Binary: 0b10000000000000000000000000000000000000000000000000000 + Octal: 0o200000000000000000 + Decimal: 4503599627370496 + Hex: 0x10000000000000 + min-x = -1.7976931348623157e308 :: Double 6 5 4 3 2 1 0 3 21098765432 1098765432109876543210987654321098765432109876543210 S ----E11---- ------------------------S52------------------------- @@ -27,13 +37,3 @@ Octal: -0o1.777777777777777774p+1023 Decimal: -1.7976931348623157e308 Hex: -0xf.ffffffffffff8p+1020 - toMetricSpace(min-x) = 4503599627370496 :: Word64 - 6 5 4 3 2 1 0 - 3210 9876 5432 1098 7654 3210 9876 5432 1098 7654 3210 9876 5432 1098 7654 3210 - Binary layout: 0000 0000 0001 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 - Hex layout: 0010 0000 0000 0000 - Type: Unsigned 64-bit word - Binary: 0b10000000000000000000000000000000000000000000000000000 - Octal: 0o200000000000000000 - Decimal: 4503599627370496 - Hex: 0x10000000000000 diff --git a/SBVTestSuite/GoldFiles/optFloat2b.gold b/SBVTestSuite/GoldFiles/optFloat2b.gold --- a/SBVTestSuite/GoldFiles/optFloat2b.gold +++ b/SBVTestSuite/GoldFiles/optFloat2b.gold @@ -1,15 +1,4 @@ Optimal model: - min-x = -Infinity :: Double - 6 5 4 3 2 1 0 - 3 21098765432 1098765432109876543210987654321098765432109876543210 - S ----E11---- ------------------------S52------------------------- - Binary layout: 1 11111111111 0000000000000000000000000000000000000000000000000000 - Hex layout: FFF0 0000 0000 0000 - Precision: Double - Sign: Negative - Exponent: 1024 (Stored: 2047, Bias: 1023) - Classification: FP_INFINITE - Value: -Infinity x = -Infinity :: Double 6 5 4 3 2 1 0 3 21098765432 1098765432109876543210987654321098765432109876543210 @@ -31,3 +20,14 @@ Octal: 0o177777777777777777 Decimal: 4503599627370495 Hex: 0xfffffffffffff + min-x = -Infinity :: Double + 6 5 4 3 2 1 0 + 3 21098765432 1098765432109876543210987654321098765432109876543210 + S ----E11---- ------------------------S52------------------------- + Binary layout: 1 11111111111 0000000000000000000000000000000000000000000000000000 + Hex layout: FFF0 0000 0000 0000 + Precision: Double + Sign: Negative + Exponent: 1024 (Stored: 2047, Bias: 1023) + Classification: FP_INFINITE + Value: -Infinity diff --git a/SBVTestSuite/GoldFiles/optFloat2c.gold b/SBVTestSuite/GoldFiles/optFloat2c.gold --- a/SBVTestSuite/GoldFiles/optFloat2c.gold +++ b/SBVTestSuite/GoldFiles/optFloat2c.gold @@ -1,5 +1,5 @@ Optimal model: - max-x = 1.7976931348623157e308 :: Double + x = 1.7976931348623157e308 :: Double 6 5 4 3 2 1 0 3 21098765432 1098765432109876543210987654321098765432109876543210 S ----E11---- ------------------------S52------------------------- @@ -13,7 +13,17 @@ Octal: 0o1.777777777777777774p+1023 Decimal: 1.7976931348623157e308 Hex: 0xf.ffffffffffff8p+1020 - x = 1.7976931348623157e308 :: Double + toMetricSpace(max-x) = 18442240474082181119 :: Word64 + 6 5 4 3 2 1 0 + 3210 9876 5432 1098 7654 3210 9876 5432 1098 7654 3210 9876 5432 1098 7654 3210 + 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: 0b1111111111101111111111111111111111111111111111111111111111111111 + Octal: 0o1777577777777777777777 + Decimal: 18442240474082181119 + Hex: 0xffefffffffffffff + max-x = 1.7976931348623157e308 :: Double 6 5 4 3 2 1 0 3 21098765432 1098765432109876543210987654321098765432109876543210 S ----E11---- ------------------------S52------------------------- @@ -27,13 +37,3 @@ Octal: 0o1.777777777777777774p+1023 Decimal: 1.7976931348623157e308 Hex: 0xf.ffffffffffff8p+1020 - toMetricSpace(max-x) = 18442240474082181119 :: Word64 - 6 5 4 3 2 1 0 - 3210 9876 5432 1098 7654 3210 9876 5432 1098 7654 3210 9876 5432 1098 7654 3210 - 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: 0b1111111111101111111111111111111111111111111111111111111111111111 - Octal: 0o1777577777777777777777 - Decimal: 18442240474082181119 - Hex: 0xffefffffffffffff diff --git a/SBVTestSuite/GoldFiles/optFloat2d.gold b/SBVTestSuite/GoldFiles/optFloat2d.gold --- a/SBVTestSuite/GoldFiles/optFloat2d.gold +++ b/SBVTestSuite/GoldFiles/optFloat2d.gold @@ -1,15 +1,4 @@ Optimal model: - max-y = Infinity :: Double - 6 5 4 3 2 1 0 - 3 21098765432 1098765432109876543210987654321098765432109876543210 - S ----E11---- ------------------------S52------------------------- - Binary layout: 0 11111111111 0000000000000000000000000000000000000000000000000000 - Hex layout: 7FF0 0000 0000 0000 - Precision: Double - Sign: Positive - Exponent: 1024 (Stored: 2047, Bias: 1023) - Classification: FP_INFINITE - Value: Infinity x = Infinity :: Double 6 5 4 3 2 1 0 3 21098765432 1098765432109876543210987654321098765432109876543210 @@ -31,3 +20,14 @@ Octal: 0o1777600000000000000000 Decimal: 18442240474082181120 Hex: 0xfff0000000000000 + max-y = Infinity :: Double + 6 5 4 3 2 1 0 + 3 21098765432 1098765432109876543210987654321098765432109876543210 + S ----E11---- ------------------------S52------------------------- + Binary layout: 0 11111111111 0000000000000000000000000000000000000000000000000000 + Hex layout: 7FF0 0000 0000 0000 + Precision: Double + Sign: Positive + Exponent: 1024 (Stored: 2047, Bias: 1023) + Classification: FP_INFINITE + Value: Infinity diff --git a/SBVTestSuite/GoldFiles/optFloat3.gold b/SBVTestSuite/GoldFiles/optFloat3.gold --- a/SBVTestSuite/GoldFiles/optFloat3.gold +++ b/SBVTestSuite/GoldFiles/optFloat3.gold @@ -1,32 +1,4 @@ Optimal model: - max-x+y = 3.4028235e38 :: Float - 3 2 1 0 - 1 09876543 21098765432109876543210 - S ---E8--- ----------S23---------- - Binary layout: 0 11111110 11111111111111111111111 - Hex layout: 7F7F FFFF - Precision: Single - Sign: Positive - Exponent: 127 (Stored: 254, Bias: 127) - Classification: FP_NORMAL - Binary: 0b1.11111111111111111111111p+127 - Octal: 0o3.77777774p+126 - Decimal: 3.4028235e38 - Hex: 0xf.fffffp+124 - metric-max-x+y = 3.4028235e38 :: Float - 3 2 1 0 - 1 09876543 21098765432109876543210 - S ---E8--- ----------S23---------- - Binary layout: 0 11111110 11111111111111111111111 - Hex layout: 7F7F FFFF - Precision: Single - Sign: Positive - Exponent: 127 (Stored: 254, Bias: 127) - Classification: FP_NORMAL - Binary: 0b1.11111111111111111111111p+127 - Octal: 0o3.77777774p+126 - Decimal: 3.4028235e38 - Hex: 0xf.fffffp+124 x = 1.7014117e38 :: Float 3 2 1 0 1 09876543 21098765432109876543210 @@ -65,3 +37,31 @@ Octal: 0o37737777777 Decimal: 4286578687 Hex: 0xff7fffff + max-x+y = 3.4028235e38 :: Float + 3 2 1 0 + 1 09876543 21098765432109876543210 + S ---E8--- ----------S23---------- + Binary layout: 0 11111110 11111111111111111111111 + Hex layout: 7F7F FFFF + Precision: Single + Sign: Positive + Exponent: 127 (Stored: 254, Bias: 127) + Classification: FP_NORMAL + Binary: 0b1.11111111111111111111111p+127 + Octal: 0o3.77777774p+126 + Decimal: 3.4028235e38 + Hex: 0xf.fffffp+124 + metric-max-x+y = 3.4028235e38 :: Float + 3 2 1 0 + 1 09876543 21098765432109876543210 + S ---E8--- ----------S23---------- + Binary layout: 0 11111110 11111111111111111111111 + Hex layout: 7F7F FFFF + Precision: Single + Sign: Positive + Exponent: 127 (Stored: 254, Bias: 127) + Classification: FP_NORMAL + Binary: 0b1.11111111111111111111111p+127 + Octal: 0o3.77777774p+126 + Decimal: 3.4028235e38 + Hex: 0xf.fffffp+124 diff --git a/SBVTestSuite/GoldFiles/optFloat4.gold b/SBVTestSuite/GoldFiles/optFloat4.gold --- a/SBVTestSuite/GoldFiles/optFloat4.gold +++ b/SBVTestSuite/GoldFiles/optFloat4.gold @@ -1,32 +1,4 @@ Optimal model: - metric-min-x+y = 3.0e-45 :: Float - 3 2 1 0 - 1 09876543 21098765432109876543210 - S ---E8--- ----------S23---------- - Binary layout: 0 00000000 00000000000000000000010 - Hex layout: 0000 0002 - Precision: Single - Sign: Positive - Exponent: -126 (Subnormal, with fixed exponent value. Stored: 0, Bias: 127) - Classification: FP_SUBNORMAL - Binary: 0b1p-148 - Octal: 0o4p-150 - Decimal: 3.0e-45 - Hex: 0x1p-148 - min-x+y = 3.0e-45 :: Float - 3 2 1 0 - 1 09876543 21098765432109876543210 - S ---E8--- ----------S23---------- - Binary layout: 0 00000000 00000000000000000000010 - Hex layout: 0000 0002 - Precision: Single - Sign: Positive - Exponent: -126 (Subnormal, with fixed exponent value. Stored: 0, Bias: 127) - Classification: FP_SUBNORMAL - Binary: 0b1p-148 - Octal: 0o4p-150 - Decimal: 3.0e-45 - Hex: 0x1p-148 x = 1.0e-45 :: Float 3 2 1 0 1 09876543 21098765432109876543210 @@ -65,3 +37,31 @@ Octal: 0o20000000002 Decimal: 2147483650 Hex: 0x80000002 + metric-min-x+y = 3.0e-45 :: Float + 3 2 1 0 + 1 09876543 21098765432109876543210 + S ---E8--- ----------S23---------- + Binary layout: 0 00000000 00000000000000000000010 + Hex layout: 0000 0002 + Precision: Single + Sign: Positive + Exponent: -126 (Subnormal, with fixed exponent value. Stored: 0, Bias: 127) + Classification: FP_SUBNORMAL + Binary: 0b1p-148 + Octal: 0o4p-150 + Decimal: 3.0e-45 + Hex: 0x1p-148 + min-x+y = 3.0e-45 :: Float + 3 2 1 0 + 1 09876543 21098765432109876543210 + S ---E8--- ----------S23---------- + Binary layout: 0 00000000 00000000000000000000010 + Hex layout: 0000 0002 + Precision: Single + Sign: Positive + Exponent: -126 (Subnormal, with fixed exponent value. Stored: 0, Bias: 127) + Classification: FP_SUBNORMAL + Binary: 0b1p-148 + Octal: 0o4p-150 + Decimal: 3.0e-45 + Hex: 0x1p-148 diff --git a/SBVTestSuite/GoldFiles/qUninterp1.gold b/SBVTestSuite/GoldFiles/qUninterp1.gold --- a/SBVTestSuite/GoldFiles/qUninterp1.gold +++ b/SBVTestSuite/GoldFiles/qUninterp1.gold @@ -26,9 +26,9 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (s0)) -[RECV] ((s0 A)) +[RECV] ((s0 B)) *** Solver : Z3 *** Exit code: ExitSuccess - FINAL:A + FINAL:B DONE! diff --git a/SBVTestSuite/GoldFiles/query1.gold b/SBVTestSuite/GoldFiles/query1.gold --- a/SBVTestSuite/GoldFiles/query1.gold +++ b/SBVTestSuite/GoldFiles/query1.gold @@ -56,9 +56,8 @@ [SEND] (get-option :produce-proofs) [RECV] true [SEND] (get-option :produce-unsat-assumptions) -[RECV] unsupported +[RECV] true [SEND] (get-option :produce-unsat-cores) -[SKIP] ; :produce-unsat-assumptions line: 40 position: 0 [RECV] true [SEND] (get-option :random-seed) [RECV] 123 @@ -74,7 +73,7 @@ [SEND] (get-info :reason-unknown) [RECV] (:reason-unknown "state of the most recent check-sat command is not known") [SEND] (get-info :version) -[RECV] (:version "4.13.4") +[RECV] (:version "4.14.1") [SEND] (get-info :status) [RECV] (:status sat) [GOOD] (define-fun s16 () Int 4) @@ -97,7 +96,7 @@ [SEND] (get-info :assertion-stack-levels) [RECV] (:assertion-stack-levels 0) [SEND] (get-info :authors) -[RECV] (:authors "Leonardo de Moura, Nikolaj Bjorner and Christoph Wintersteiger") +[RECV] (:authors "Leonardo de Moura, Nikolaj Bjorner, Lev Nachmanson and Christoph Wintersteiger") [SEND] (get-info :error-behavior) [RECV] (:error-behavior continued-execution) [SEND] (get-info :name) @@ -105,14 +104,32 @@ [SEND] (get-info :reason-unknown) [RECV] (:reason-unknown "unknown") [SEND] (get-info :version) -[RECV] (:version "4.13.4") +[RECV] (:version "4.14.1") [SEND] (get-info :memory) [RECV] unsupported [SEND] (get-info :time) [SKIP] ; :memory line: 69 position: 0 +[SKIP] ; Suppported get-info parameters: +[SKIP] ; (get-info :reason-unknown) +[SKIP] ; (get-info :status) +[SKIP] ; (get-info :version) +[SKIP] ; (get-info :authors) +[SKIP] ; (get-info :error-behavior) +[SKIP] ; (get-info :parameters) +[SKIP] ; (get-info :rlimit) +[SKIP] ; (get-info :assertion-stack-levels) [RECV] unsupported [SEND] (get-value (s0)) [SKIP] ; :time line: 70 position: 0 +[SKIP] ; Suppported get-info parameters: +[SKIP] ; (get-info :reason-unknown) +[SKIP] ; (get-info :status) +[SKIP] ; (get-info :version) +[SKIP] ; (get-info :authors) +[SKIP] ; (get-info :error-behavior) +[SKIP] ; (get-info :parameters) +[SKIP] ; (get-info :rlimit) +[SKIP] ; (get-info :assertion-stack-levels) [RECV] ((s0 5)) [SEND] (get-value (s1)) [RECV] ((s1 1)) diff --git a/SBVTestSuite/GoldFiles/query_uisatex1.gold b/SBVTestSuite/GoldFiles/query_uisatex1.gold --- a/SBVTestSuite/GoldFiles/query_uisatex1.gold +++ b/SBVTestSuite/GoldFiles/query_uisatex1.gold @@ -20,33 +20,34 @@ [GOOD] (define-fun s9 () Int (- 3)) [GOOD] (define-fun s11 () Int 9) [GOOD] (define-fun s14 () Int 1) -[GOOD] (define-fun s17 () Int 0) -[GOOD] (define-fun s20 () Int 5) -[GOOD] (define-fun s22 () Int 7) -[GOOD] (define-fun s24 () Int 6) -[GOOD] (define-fun s28 () (_ FloatingPoint 8 24) ((_ to_fp 8 24) roundNearestTiesToEven (/ 4508877.0 524288.0))) -[GOOD] (define-fun s31 () (_ FloatingPoint 8 24) ((_ to_fp 8 24) roundNearestTiesToEven (/ 5033165.0 524288.0))) -[GOOD] (define-fun s32 () Int 121) -[GOOD] (define-fun s37 () Int 8) -[GOOD] (define-fun s39 () (_ FloatingPoint 8 24) (_ +oo 8 24)) -[GOOD] (define-fun s41 () String (_ char #x63)) -[GOOD] (define-fun s42 () String "hey") -[GOOD] (define-fun s44 () (_ FloatingPoint 8 24) ((_ to_fp 8 24) roundNearestTiesToEven (/ 78.0 1.0))) -[GOOD] (define-fun s46 () String "tey") -[GOOD] (define-fun s48 () (_ FloatingPoint 8 24) ((_ to_fp 8 24) roundNearestTiesToEven (/ 92.0 1.0))) -[GOOD] (define-fun s50 () String (_ char #x72)) -[GOOD] (define-fun s51 () String "foo") -[GOOD] (define-fun s53 () (_ FloatingPoint 8 24) ((_ to_fp 8 24) roundNearestTiesToEven (/ 7.0 2.0))) -[GOOD] (define-fun s55 () (Seq Int) (seq.++ (seq.unit 1) (seq.unit 2) (seq.unit 3))) -[GOOD] (define-fun s56 () (Seq (_ FloatingPoint 8 24)) (seq.++ (seq.unit ((_ to_fp 8 24) roundNearestTiesToEven (/ 8598323.0 1048576.0))) (seq.unit ((_ to_fp 8 24) roundNearestTiesToEven (/ 3.0 1.0))))) -[GOOD] (define-fun s59 () (Seq Int) (seq.++ (seq.unit 9) (seq.unit 5))) -[GOOD] (define-fun s60 () (Seq (_ FloatingPoint 8 24)) (seq.++ (seq.unit ((_ to_fp 8 24) roundNearestTiesToEven (/ 8598323.0 1048576.0))) (seq.unit ((_ to_fp 8 24) roundNearestTiesToEven (/ 9.0 1.0))))) -[GOOD] (define-fun s62 () Int 21) -[GOOD] (define-fun s64 () (Seq Int) (seq.unit 5)) -[GOOD] (define-fun s65 () (Seq (_ FloatingPoint 8 24)) (seq.++ (seq.unit ((_ to_fp 8 24) roundNearestTiesToEven (/ 8598323.0 1048576.0))) (seq.unit (_ +zero 8 24)))) -[GOOD] (define-fun s67 () Int 210) +[GOOD] (define-fun s21 () Int 5) +[GOOD] (define-fun s23 () Int 7) +[GOOD] (define-fun s25 () Int 6) +[GOOD] (define-fun s29 () (_ FloatingPoint 8 24) ((_ to_fp 8 24) roundNearestTiesToEven (/ 4508877.0 524288.0))) +[GOOD] (define-fun s32 () (_ FloatingPoint 8 24) ((_ to_fp 8 24) roundNearestTiesToEven (/ 5033165.0 524288.0))) +[GOOD] (define-fun s33 () Int 121) +[GOOD] (define-fun s38 () Int 8) +[GOOD] (define-fun s40 () (_ FloatingPoint 8 24) (_ +oo 8 24)) +[GOOD] (define-fun s42 () String (_ char #x63)) +[GOOD] (define-fun s43 () String "hey") +[GOOD] (define-fun s45 () (_ FloatingPoint 8 24) ((_ to_fp 8 24) roundNearestTiesToEven (/ 78.0 1.0))) +[GOOD] (define-fun s47 () String "tey") +[GOOD] (define-fun s49 () (_ FloatingPoint 8 24) ((_ to_fp 8 24) roundNearestTiesToEven (/ 92.0 1.0))) +[GOOD] (define-fun s51 () String (_ char #x72)) +[GOOD] (define-fun s52 () String "foo") +[GOOD] (define-fun s54 () (_ FloatingPoint 8 24) ((_ to_fp 8 24) roundNearestTiesToEven (/ 7.0 2.0))) +[GOOD] (define-fun s56 () (Seq Int) (seq.++ (seq.unit 1) (seq.unit 2) (seq.unit 3))) +[GOOD] (define-fun s57 () (Seq (_ FloatingPoint 8 24)) (seq.++ (seq.unit ((_ to_fp 8 24) roundNearestTiesToEven (/ 8598323.0 1048576.0))) (seq.unit ((_ to_fp 8 24) roundNearestTiesToEven (/ 3.0 1.0))))) +[GOOD] (define-fun s60 () (Seq Int) (seq.++ (seq.unit 9) (seq.unit 5))) +[GOOD] (define-fun s61 () (Seq (_ FloatingPoint 8 24)) (seq.++ (seq.unit ((_ to_fp 8 24) roundNearestTiesToEven (/ 8598323.0 1048576.0))) (seq.unit ((_ to_fp 8 24) roundNearestTiesToEven (/ 9.0 1.0))))) +[GOOD] (define-fun s63 () Int 21) +[GOOD] (define-fun s65 () (Seq Int) (seq.unit 5)) +[GOOD] (define-fun s66 () (Seq (_ FloatingPoint 8 24)) (seq.++ (seq.unit ((_ to_fp 8 24) roundNearestTiesToEven (/ 8598323.0 1048576.0))) (seq.unit (_ +zero 8 24)))) +[GOOD] (define-fun s68 () Int 210) [GOOD] ; --- top level inputs --- [GOOD] (declare-fun s0 () Int) +[GOOD] (declare-fun s17 () Bool) ; tracks user variable "__internal_sbv_s17" +[GOOD] (declare-fun s18 () Int) ; tracks user variable "__internal_sbv_s18" [GOOD] ; --- constant tables --- [GOOD] ; --- non-constant tables --- [GOOD] ; --- uninterpreted constants --- @@ -66,55 +67,59 @@ [GOOD] (define-fun s13 () Int (q1 s0)) [GOOD] (define-fun s15 () Int (+ s0 s14)) [GOOD] (define-fun s16 () Bool (= s13 s15)) -[GOOD] (define-fun s18 () Int (q2 false s17)) -[GOOD] (define-fun s19 () Int (q2 true s5)) -[GOOD] (define-fun s21 () Bool (= s19 s20)) -[GOOD] (define-fun s23 () Int (q2 false s22)) -[GOOD] (define-fun s25 () Bool (= s23 s24)) -[GOOD] (define-fun s26 () Int (q2 false s3)) -[GOOD] (define-fun s27 () Bool (= s5 s26)) -[GOOD] (define-fun s29 () (_ FloatingPoint 8 24) (q3 s28 true s3)) -[GOOD] (define-fun s30 () Bool (fp.eq s28 s29)) -[GOOD] (define-fun s33 () (_ FloatingPoint 8 24) (q3 s31 true s32)) -[GOOD] (define-fun s34 () Bool (fp.isZero s33)) -[GOOD] (define-fun s35 () Bool (fp.isNegative s33)) -[GOOD] (define-fun s36 () Bool (and s34 s35)) -[GOOD] (define-fun s38 () (_ FloatingPoint 8 24) (q3 s31 false s37)) -[GOOD] (define-fun s40 () Bool (fp.eq s38 s39)) -[GOOD] (define-fun s43 () (_ FloatingPoint 8 24) (q4 s41 s42)) -[GOOD] (define-fun s45 () Bool (fp.eq s43 s44)) -[GOOD] (define-fun s47 () (_ FloatingPoint 8 24) (q4 s41 s46)) -[GOOD] (define-fun s49 () Bool (fp.eq s47 s48)) -[GOOD] (define-fun s52 () (_ FloatingPoint 8 24) (q4 s50 s51)) -[GOOD] (define-fun s54 () Bool (fp.eq s52 s53)) -[GOOD] (define-fun s57 () Int (q5 s55 s56)) -[GOOD] (define-fun s58 () Bool (= s22 s57)) -[GOOD] (define-fun s61 () Int (q5 s59 s60)) -[GOOD] (define-fun s63 () Bool (= s61 s62)) -[GOOD] (define-fun s66 () Int (q5 s64 s65)) -[GOOD] (define-fun s68 () Bool (= s66 s67)) +[GOOD] (define-fun s19 () Int (q2 s17 s18)) +[GOOD] (define-fun s20 () Int (q2 true s5)) +[GOOD] (define-fun s22 () Bool (= s20 s21)) +[GOOD] (define-fun s24 () Int (q2 false s23)) +[GOOD] (define-fun s26 () Bool (= s24 s25)) +[GOOD] (define-fun s27 () Int (q2 false s3)) +[GOOD] (define-fun s28 () Bool (= s5 s27)) +[GOOD] (define-fun s30 () (_ FloatingPoint 8 24) (q3 s29 true s3)) +[GOOD] (define-fun s31 () Bool (fp.eq s29 s30)) +[GOOD] (define-fun s34 () (_ FloatingPoint 8 24) (q3 s32 true s33)) +[GOOD] (define-fun s35 () Bool (fp.isZero s34)) +[GOOD] (define-fun s36 () Bool (fp.isNegative s34)) +[GOOD] (define-fun s37 () Bool (and s35 s36)) +[GOOD] (define-fun s39 () (_ FloatingPoint 8 24) (q3 s32 false s38)) +[GOOD] (define-fun s41 () Bool (fp.eq s39 s40)) +[GOOD] (define-fun s44 () (_ FloatingPoint 8 24) (q4 s42 s43)) +[GOOD] (define-fun s46 () Bool (fp.eq s44 s45)) +[GOOD] (define-fun s48 () (_ FloatingPoint 8 24) (q4 s42 s47)) +[GOOD] (define-fun s50 () Bool (fp.eq s48 s49)) +[GOOD] (define-fun s53 () (_ FloatingPoint 8 24) (q4 s51 s52)) +[GOOD] (define-fun s55 () Bool (fp.eq s53 s54)) +[GOOD] (define-fun s58 () Int (q5 s56 s57)) +[GOOD] (define-fun s59 () Bool (= s23 s58)) +[GOOD] (define-fun s62 () Int (q5 s60 s61)) +[GOOD] (define-fun s64 () Bool (= s62 s63)) +[GOOD] (define-fun s67 () Int (q5 s65 s66)) +[GOOD] (define-fun s69 () Bool (= s67 s68)) [GOOD] ; --- delayedEqualities --- [GOOD] ; --- formula --- [GOOD] (assert s4) [GOOD] (assert s8) [GOOD] (assert s12) [GOOD] (assert s16) -[GOOD] (assert s21) -[GOOD] (assert s25) -[GOOD] (assert s27) -[GOOD] (assert s30) -[GOOD] (assert s36) -[GOOD] (assert s40) -[GOOD] (assert s45) -[GOOD] (assert s49) -[GOOD] (assert s54) -[GOOD] (assert s58) -[GOOD] (assert s63) -[GOOD] (assert s68) +[GOOD] (assert s22) +[GOOD] (assert s26) +[GOOD] (assert s28) +[GOOD] (assert s31) +[GOOD] (assert s37) +[GOOD] (assert s41) +[GOOD] (assert s46) +[GOOD] (assert s50) +[GOOD] (assert s55) +[GOOD] (assert s59) +[GOOD] (assert s64) +[GOOD] (assert s69) [SEND] (check-sat) [RECV] sat [SEND] (get-value (s0)) [RECV] ((s0 0)) +[SEND] (get-value (s17)) +[RECV] ((s17 false)) +[SEND] (get-value (s18)) +[RECV] ((s18 0)) [GOOD] (set-option :pp.max_depth 4294967295) [GOOD] (set-option :pp.min_alias_size 4294967295) [GOOD] (set-option :model.inline_def true ) diff --git a/SBVTestSuite/GoldFiles/query_uisatex2.gold b/SBVTestSuite/GoldFiles/query_uisatex2.gold --- a/SBVTestSuite/GoldFiles/query_uisatex2.gold +++ b/SBVTestSuite/GoldFiles/query_uisatex2.gold @@ -20,33 +20,35 @@ [GOOD] (define-fun s9 () Int (- 3)) [GOOD] (define-fun s11 () Int 9) [GOOD] (define-fun s14 () Int 1) -[GOOD] (define-fun s17 () Int 0) -[GOOD] (define-fun s20 () Int 5) -[GOOD] (define-fun s22 () Int 7) -[GOOD] (define-fun s24 () Int 6) -[GOOD] (define-fun s28 () (_ FloatingPoint 8 24) ((_ to_fp 8 24) roundNearestTiesToEven (/ 4508877.0 524288.0))) -[GOOD] (define-fun s31 () (_ FloatingPoint 8 24) ((_ to_fp 8 24) roundNearestTiesToEven (/ 5033165.0 524288.0))) -[GOOD] (define-fun s32 () Int 121) -[GOOD] (define-fun s37 () Int 8) -[GOOD] (define-fun s39 () (_ FloatingPoint 8 24) (_ +oo 8 24)) -[GOOD] (define-fun s41 () String (_ char #x63)) -[GOOD] (define-fun s42 () String "hey") -[GOOD] (define-fun s44 () (_ FloatingPoint 8 24) ((_ to_fp 8 24) roundNearestTiesToEven (/ 78.0 1.0))) -[GOOD] (define-fun s46 () String "tey") -[GOOD] (define-fun s48 () (_ FloatingPoint 8 24) ((_ to_fp 8 24) roundNearestTiesToEven (/ 92.0 1.0))) -[GOOD] (define-fun s50 () String (_ char #x72)) -[GOOD] (define-fun s51 () String "foo") -[GOOD] (define-fun s53 () (_ FloatingPoint 8 24) ((_ to_fp 8 24) roundNearestTiesToEven (/ 7.0 2.0))) -[GOOD] (define-fun s55 () (Seq Int) (seq.++ (seq.unit 1) (seq.unit 2) (seq.unit 3))) -[GOOD] (define-fun s56 () (Seq (_ FloatingPoint 8 24)) (seq.++ (seq.unit ((_ to_fp 8 24) roundNearestTiesToEven (/ 8598323.0 1048576.0))) (seq.unit ((_ to_fp 8 24) roundNearestTiesToEven (/ 3.0 1.0))))) -[GOOD] (define-fun s59 () (Seq Int) (seq.++ (seq.unit 9) (seq.unit 5))) -[GOOD] (define-fun s60 () (Seq (_ FloatingPoint 8 24)) (seq.++ (seq.unit ((_ to_fp 8 24) roundNearestTiesToEven (/ 8598323.0 1048576.0))) (seq.unit ((_ to_fp 8 24) roundNearestTiesToEven (/ 9.0 1.0))))) -[GOOD] (define-fun s62 () Int 21) -[GOOD] (define-fun s64 () (Seq Int) (seq.unit 5)) -[GOOD] (define-fun s65 () (Seq (_ FloatingPoint 8 24)) (seq.++ (seq.unit ((_ to_fp 8 24) roundNearestTiesToEven (/ 8598323.0 1048576.0))) (seq.unit (_ +zero 8 24)))) -[GOOD] (define-fun s67 () Int 210) +[GOOD] (define-fun s21 () Int 5) +[GOOD] (define-fun s23 () Int 7) +[GOOD] (define-fun s25 () Int 6) +[GOOD] (define-fun s29 () (_ FloatingPoint 8 24) ((_ to_fp 8 24) roundNearestTiesToEven (/ 4508877.0 524288.0))) +[GOOD] (define-fun s32 () (_ FloatingPoint 8 24) ((_ to_fp 8 24) roundNearestTiesToEven (/ 5033165.0 524288.0))) +[GOOD] (define-fun s33 () Int 121) +[GOOD] (define-fun s38 () Int 8) +[GOOD] (define-fun s40 () (_ FloatingPoint 8 24) (_ +oo 8 24)) +[GOOD] (define-fun s42 () String (_ char #x63)) +[GOOD] (define-fun s43 () String "hey") +[GOOD] (define-fun s45 () (_ FloatingPoint 8 24) ((_ to_fp 8 24) roundNearestTiesToEven (/ 78.0 1.0))) +[GOOD] (define-fun s47 () String "tey") +[GOOD] (define-fun s49 () (_ FloatingPoint 8 24) ((_ to_fp 8 24) roundNearestTiesToEven (/ 92.0 1.0))) +[GOOD] (define-fun s51 () String (_ char #x72)) +[GOOD] (define-fun s52 () String "foo") +[GOOD] (define-fun s54 () (_ FloatingPoint 8 24) ((_ to_fp 8 24) roundNearestTiesToEven (/ 7.0 2.0))) +[GOOD] (define-fun s56 () (Seq Int) (seq.++ (seq.unit 1) (seq.unit 2) (seq.unit 3))) +[GOOD] (define-fun s57 () (Seq (_ FloatingPoint 8 24)) (seq.++ (seq.unit ((_ to_fp 8 24) roundNearestTiesToEven (/ 8598323.0 1048576.0))) (seq.unit ((_ to_fp 8 24) roundNearestTiesToEven (/ 3.0 1.0))))) +[GOOD] (define-fun s60 () (Seq Int) (seq.++ (seq.unit 9) (seq.unit 5))) +[GOOD] (define-fun s61 () (Seq (_ FloatingPoint 8 24)) (seq.++ (seq.unit ((_ to_fp 8 24) roundNearestTiesToEven (/ 8598323.0 1048576.0))) (seq.unit ((_ to_fp 8 24) roundNearestTiesToEven (/ 9.0 1.0))))) +[GOOD] (define-fun s63 () Int 21) +[GOOD] (define-fun s65 () (Seq Int) (seq.unit 5)) +[GOOD] (define-fun s66 () (Seq (_ FloatingPoint 8 24)) (seq.++ (seq.unit ((_ to_fp 8 24) roundNearestTiesToEven (/ 8598323.0 1048576.0))) (seq.unit (_ +zero 8 24)))) +[GOOD] (define-fun s68 () Int 210) [GOOD] ; --- top level inputs --- [GOOD] (declare-fun s0 () Int) +[GOOD] (declare-fun s17 () Bool) ; tracks user variable "__internal_sbv_s17" +[GOOD] (declare-fun s18 () Int) ; tracks user variable "__internal_sbv_s18" +[GOOD] (declare-fun s70 () Int) ; tracks user variable "__internal_sbv_s70" [GOOD] ; --- constant tables --- [GOOD] ; --- non-constant tables --- [GOOD] ; --- uninterpreted constants --- @@ -67,52 +69,52 @@ [GOOD] (define-fun s13 () Int (q1 s0)) [GOOD] (define-fun s15 () Int (+ s0 s14)) [GOOD] (define-fun s16 () Bool (= s13 s15)) -[GOOD] (define-fun s18 () Int (q2 false s17)) -[GOOD] (define-fun s19 () Int (q2 true s5)) -[GOOD] (define-fun s21 () Bool (= s19 s20)) -[GOOD] (define-fun s23 () Int (q2 false s22)) -[GOOD] (define-fun s25 () Bool (= s23 s24)) -[GOOD] (define-fun s26 () Int (q2 false s3)) -[GOOD] (define-fun s27 () Bool (= s5 s26)) -[GOOD] (define-fun s29 () (_ FloatingPoint 8 24) (q3 s28 true s3)) -[GOOD] (define-fun s30 () Bool (fp.eq s28 s29)) -[GOOD] (define-fun s33 () (_ FloatingPoint 8 24) (q3 s31 true s32)) -[GOOD] (define-fun s34 () Bool (fp.isZero s33)) -[GOOD] (define-fun s35 () Bool (fp.isNegative s33)) -[GOOD] (define-fun s36 () Bool (and s34 s35)) -[GOOD] (define-fun s38 () (_ FloatingPoint 8 24) (q3 s31 false s37)) -[GOOD] (define-fun s40 () Bool (fp.eq s38 s39)) -[GOOD] (define-fun s43 () (_ FloatingPoint 8 24) (q4 s41 s42)) -[GOOD] (define-fun s45 () Bool (fp.eq s43 s44)) -[GOOD] (define-fun s47 () (_ FloatingPoint 8 24) (q4 s41 s46)) -[GOOD] (define-fun s49 () Bool (fp.eq s47 s48)) -[GOOD] (define-fun s52 () (_ FloatingPoint 8 24) (q4 s50 s51)) -[GOOD] (define-fun s54 () Bool (fp.eq s52 s53)) -[GOOD] (define-fun s57 () Int (q5 s55 s56)) -[GOOD] (define-fun s58 () Bool (= s22 s57)) -[GOOD] (define-fun s61 () Int (q5 s59 s60)) -[GOOD] (define-fun s63 () Bool (= s61 s62)) -[GOOD] (define-fun s66 () Int (q5 s64 s65)) -[GOOD] (define-fun s68 () Bool (= s66 s67)) -[GOOD] (define-fun s69 () Bool (q6 s17)) +[GOOD] (define-fun s19 () Int (q2 s17 s18)) +[GOOD] (define-fun s20 () Int (q2 true s5)) +[GOOD] (define-fun s22 () Bool (= s20 s21)) +[GOOD] (define-fun s24 () Int (q2 false s23)) +[GOOD] (define-fun s26 () Bool (= s24 s25)) +[GOOD] (define-fun s27 () Int (q2 false s3)) +[GOOD] (define-fun s28 () Bool (= s5 s27)) +[GOOD] (define-fun s30 () (_ FloatingPoint 8 24) (q3 s29 true s3)) +[GOOD] (define-fun s31 () Bool (fp.eq s29 s30)) +[GOOD] (define-fun s34 () (_ FloatingPoint 8 24) (q3 s32 true s33)) +[GOOD] (define-fun s35 () Bool (fp.isZero s34)) +[GOOD] (define-fun s36 () Bool (fp.isNegative s34)) +[GOOD] (define-fun s37 () Bool (and s35 s36)) +[GOOD] (define-fun s39 () (_ FloatingPoint 8 24) (q3 s32 false s38)) +[GOOD] (define-fun s41 () Bool (fp.eq s39 s40)) +[GOOD] (define-fun s44 () (_ FloatingPoint 8 24) (q4 s42 s43)) +[GOOD] (define-fun s46 () Bool (fp.eq s44 s45)) +[GOOD] (define-fun s48 () (_ FloatingPoint 8 24) (q4 s42 s47)) +[GOOD] (define-fun s50 () Bool (fp.eq s48 s49)) +[GOOD] (define-fun s53 () (_ FloatingPoint 8 24) (q4 s51 s52)) +[GOOD] (define-fun s55 () Bool (fp.eq s53 s54)) +[GOOD] (define-fun s58 () Int (q5 s56 s57)) +[GOOD] (define-fun s59 () Bool (= s23 s58)) +[GOOD] (define-fun s62 () Int (q5 s60 s61)) +[GOOD] (define-fun s64 () Bool (= s62 s63)) +[GOOD] (define-fun s67 () Int (q5 s65 s66)) +[GOOD] (define-fun s69 () Bool (= s67 s68)) +[GOOD] (define-fun s71 () Bool (q6 s70)) [GOOD] ; --- delayedEqualities --- [GOOD] ; --- formula --- [GOOD] (assert s4) [GOOD] (assert s8) [GOOD] (assert s12) [GOOD] (assert s16) -[GOOD] (assert s21) -[GOOD] (assert s25) -[GOOD] (assert s27) -[GOOD] (assert s30) -[GOOD] (assert s36) -[GOOD] (assert s40) -[GOOD] (assert s45) -[GOOD] (assert s49) -[GOOD] (assert s54) -[GOOD] (assert s58) -[GOOD] (assert s63) -[GOOD] (assert s68) +[GOOD] (assert s22) +[GOOD] (assert s26) +[GOOD] (assert s28) +[GOOD] (assert s31) +[GOOD] (assert s37) +[GOOD] (assert s41) +[GOOD] (assert s46) +[GOOD] (assert s50) +[GOOD] (assert s55) +[GOOD] (assert s59) +[GOOD] (assert s64) +[GOOD] (assert s69) [SEND] (check-sat) [RECV] sat [SEND] (get-value (q1)) diff --git a/SBVTestSuite/GoldFiles/reverse.gold b/SBVTestSuite/GoldFiles/reverse.gold deleted file mode 100644 --- a/SBVTestSuite/GoldFiles/reverse.gold +++ /dev/null @@ -1,123 +0,0 @@ -** 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-option :pp.max_depth 4294967295) -[GOOD] (set-option :pp.min_alias_size 4294967295) -[GOOD] (set-option :model.inline_def true ) -[GOOD] (set-logic ALL) ; has unbounded values, using catch-all. -[GOOD] ; --- uninterpreted sorts --- -[GOOD] ; --- tuples --- -[GOOD] ; --- sums --- -[GOOD] ; --- literal constants --- -[GOOD] (define-fun s12 () Int 0) -[GOOD] (define-fun s14 () (Seq Int) (as seq.empty (Seq Int))) -[GOOD] (define-fun s15 () Int 1) -[GOOD] ; --- top level inputs --- -[GOOD] (declare-fun s0 () Int) ; tracks user variable "a" -[GOOD] (declare-fun s1 () Int) ; tracks user variable "b" -[GOOD] (declare-fun s2 () Int) ; tracks user variable "c" -[GOOD] (declare-fun s3 () Int) ; tracks user variable "d" -[GOOD] ; --- constant tables --- -[GOOD] ; --- non-constant tables --- -[GOOD] ; --- uninterpreted constants --- -[GOOD] ; --- user defined functions --- -[GOOD] ; --- assignments --- -[GOOD] (define-fun s4 () (Seq Int) (seq.unit s0)) -[GOOD] (define-fun s5 () (Seq Int) (seq.unit s1)) -[GOOD] (define-fun s6 () (Seq Int) (seq.unit s2)) -[GOOD] (define-fun s7 () (Seq Int) (seq.unit s3)) -[GOOD] (define-fun s8 () (Seq Int) (seq.++ s6 s7)) -[GOOD] (define-fun s9 () (Seq Int) (seq.++ s5 s8)) -[GOOD] (define-fun s10 () (Seq Int) (seq.++ s4 s9)) -[GOOD] (define-fun s11 () Int (seq.len s10)) -[GOOD] (define-fun s13 () Bool (= s11 s12)) -[GOOD] (define-fun s16 () Int (- s11 s15)) -[GOOD] (define-fun s17 () (Seq Int) (seq.extract s10 s15 s16)) -[GOOD] (define-fun s18 () Int (seq.len s17)) -[GOOD] (define-fun s19 () Bool (= s12 s18)) -[GOOD] (define-fun s20 () Int (- s18 s15)) -[GOOD] (define-fun s21 () (Seq Int) (seq.extract s17 s15 s20)) -[GOOD] (define-fun s22 () Int (seq.len s21)) -[GOOD] (define-fun s23 () Bool (= s12 s22)) -[GOOD] (define-fun s24 () Int (- s22 s15)) -[GOOD] (define-fun s25 () (Seq Int) (seq.extract s21 s15 s24)) -[GOOD] (define-fun s26 () Int (seq.len s25)) -[GOOD] (define-fun s27 () Bool (= s12 s26)) -[GOOD] (define-fun s28 () Int (- s26 s15)) -[GOOD] (define-fun s29 () (Seq Int) (seq.extract s25 s15 s28)) -[GOOD] (define-fun s30 () Int (seq.len s29)) -[GOOD] (define-fun s31 () Bool (= s12 s30)) -[GOOD] (define-fun s32 () Int (- s30 s15)) -[GOOD] (define-fun s33 () (Seq Int) (seq.extract s29 s15 s32)) -[GOOD] (define-fun s34 () Int (seq.len s33)) -[GOOD] (define-fun s35 () Bool (= s12 s34)) -[GOOD] (define-fun s36 () Int (- s34 s15)) -[GOOD] (define-fun s37 () (Seq Int) (seq.extract s33 s15 s36)) -[GOOD] (define-fun s38 () Int (seq.len s37)) -[GOOD] (define-fun s39 () Bool (= s12 s38)) -[GOOD] (define-fun s40 () Int (- s38 s15)) -[GOOD] (define-fun s41 () (Seq Int) (seq.extract s37 s15 s40)) -[GOOD] (define-fun s42 () Int (seq.len s41)) -[GOOD] (define-fun s43 () Bool (= s12 s42)) -[GOOD] (define-fun s44 () Int (- s42 s15)) -[GOOD] (define-fun s45 () (Seq Int) (seq.extract s41 s15 s44)) -[GOOD] (define-fun s46 () Int (seq.len s45)) -[GOOD] (define-fun s47 () Bool (= s12 s46)) -[GOOD] (define-fun s48 () Int (- s46 s15)) -[GOOD] (define-fun s49 () (Seq Int) (seq.extract s45 s15 s48)) -[GOOD] (define-fun s50 () Int (seq.len s49)) -[GOOD] (define-fun s51 () Bool (= s12 s50)) -[GOOD] (define-fun s52 () Int (seq.nth s49 s12)) -[GOOD] (define-fun s53 () (Seq Int) (seq.unit s52)) -[GOOD] (define-fun s54 () (Seq Int) (ite s51 s14 s53)) -[GOOD] (define-fun s55 () Int (seq.nth s45 s12)) -[GOOD] (define-fun s56 () (Seq Int) (seq.unit s55)) -[GOOD] (define-fun s57 () (Seq Int) (seq.++ s54 s56)) -[GOOD] (define-fun s58 () (Seq Int) (ite s47 s14 s57)) -[GOOD] (define-fun s59 () Int (seq.nth s41 s12)) -[GOOD] (define-fun s60 () (Seq Int) (seq.unit s59)) -[GOOD] (define-fun s61 () (Seq Int) (seq.++ s58 s60)) -[GOOD] (define-fun s62 () (Seq Int) (ite s43 s14 s61)) -[GOOD] (define-fun s63 () Int (seq.nth s37 s12)) -[GOOD] (define-fun s64 () (Seq Int) (seq.unit s63)) -[GOOD] (define-fun s65 () (Seq Int) (seq.++ s62 s64)) -[GOOD] (define-fun s66 () (Seq Int) (ite s39 s14 s65)) -[GOOD] (define-fun s67 () Int (seq.nth s33 s12)) -[GOOD] (define-fun s68 () (Seq Int) (seq.unit s67)) -[GOOD] (define-fun s69 () (Seq Int) (seq.++ s66 s68)) -[GOOD] (define-fun s70 () (Seq Int) (ite s35 s14 s69)) -[GOOD] (define-fun s71 () Int (seq.nth s29 s12)) -[GOOD] (define-fun s72 () (Seq Int) (seq.unit s71)) -[GOOD] (define-fun s73 () (Seq Int) (seq.++ s70 s72)) -[GOOD] (define-fun s74 () (Seq Int) (ite s31 s14 s73)) -[GOOD] (define-fun s75 () Int (seq.nth s25 s12)) -[GOOD] (define-fun s76 () (Seq Int) (seq.unit s75)) -[GOOD] (define-fun s77 () (Seq Int) (seq.++ s74 s76)) -[GOOD] (define-fun s78 () (Seq Int) (ite s27 s14 s77)) -[GOOD] (define-fun s79 () Int (seq.nth s21 s12)) -[GOOD] (define-fun s80 () (Seq Int) (seq.unit s79)) -[GOOD] (define-fun s81 () (Seq Int) (seq.++ s78 s80)) -[GOOD] (define-fun s82 () (Seq Int) (ite s23 s14 s81)) -[GOOD] (define-fun s83 () Int (seq.nth s17 s12)) -[GOOD] (define-fun s84 () (Seq Int) (seq.unit s83)) -[GOOD] (define-fun s85 () (Seq Int) (seq.++ s82 s84)) -[GOOD] (define-fun s86 () (Seq Int) (ite s19 s14 s85)) -[GOOD] (define-fun s87 () Int (seq.nth s10 s12)) -[GOOD] (define-fun s88 () (Seq Int) (seq.unit s87)) -[GOOD] (define-fun s89 () (Seq Int) (seq.++ s86 s88)) -[GOOD] (define-fun s90 () (Seq Int) (ite s13 s14 s89)) -[GOOD] (define-fun s91 () (Seq Int) (seq.++ s5 s4)) -[GOOD] (define-fun s92 () (Seq Int) (seq.++ s6 s91)) -[GOOD] (define-fun s93 () (Seq Int) (seq.++ s7 s92)) -[GOOD] (define-fun s94 () Bool (= s90 s93)) -[GOOD] ; --- delayedEqualities --- -[GOOD] ; --- formula --- -[GOOD] (assert s94) -[SEND] (check-sat) -[RECV] sat -*** Solver : Z3 -*** Exit code: ExitSuccess diff --git a/SBVTestSuite/GoldFiles/reverseAlt10.gold b/SBVTestSuite/GoldFiles/reverseAlt10.gold deleted file mode 100644 --- a/SBVTestSuite/GoldFiles/reverseAlt10.gold +++ /dev/null @@ -1,129 +0,0 @@ -** 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-option :pp.max_depth 4294967295) -[GOOD] (set-option :pp.min_alias_size 4294967295) -[GOOD] (set-option :model.inline_def true ) -[GOOD] (set-logic ALL) ; has unbounded values, using catch-all. -[GOOD] ; --- uninterpreted sorts --- -[GOOD] ; --- tuples --- -[GOOD] ; --- sums --- -[GOOD] ; --- literal constants --- -[GOOD] (define-fun s2 () Int 0) -[GOOD] (define-fun s4 () (Seq Int) (as seq.empty (Seq Int))) -[GOOD] (define-fun s5 () Int 1) -[GOOD] ; --- top level inputs --- -[GOOD] (declare-fun s0 () (Seq Int)) ; tracks user variable "xs" -[GOOD] ; --- constant tables --- -[GOOD] ; --- non-constant tables --- -[GOOD] ; --- uninterpreted constants --- -[GOOD] ; --- user defined functions --- -[GOOD] ; --- assignments --- -[GOOD] (define-fun s1 () Int (seq.len s0)) -[GOOD] (define-fun s3 () Bool (= s1 s2)) -[GOOD] (define-fun s6 () Int (- s1 s5)) -[GOOD] (define-fun s7 () (Seq Int) (seq.extract s0 s5 s6)) -[GOOD] (define-fun s8 () Int (seq.len s7)) -[GOOD] (define-fun s9 () Bool (= s2 s8)) -[GOOD] (define-fun s10 () Int (- s8 s5)) -[GOOD] (define-fun s11 () (Seq Int) (seq.extract s7 s5 s10)) -[GOOD] (define-fun s12 () Int (seq.len s11)) -[GOOD] (define-fun s13 () Bool (= s2 s12)) -[GOOD] (define-fun s14 () Int (- s12 s5)) -[GOOD] (define-fun s15 () (Seq Int) (seq.extract s11 s5 s14)) -[GOOD] (define-fun s16 () Int (seq.len s15)) -[GOOD] (define-fun s17 () Bool (= s2 s16)) -[GOOD] (define-fun s18 () Int (- s16 s5)) -[GOOD] (define-fun s19 () (Seq Int) (seq.extract s15 s5 s18)) -[GOOD] (define-fun s20 () Int (seq.len s19)) -[GOOD] (define-fun s21 () Bool (= s2 s20)) -[GOOD] (define-fun s22 () Int (- s20 s5)) -[GOOD] (define-fun s23 () (Seq Int) (seq.extract s19 s5 s22)) -[GOOD] (define-fun s24 () Int (seq.len s23)) -[GOOD] (define-fun s25 () Bool (= s2 s24)) -[GOOD] (define-fun s26 () Int (- s24 s5)) -[GOOD] (define-fun s27 () (Seq Int) (seq.extract s23 s5 s26)) -[GOOD] (define-fun s28 () Int (seq.len s27)) -[GOOD] (define-fun s29 () Bool (= s2 s28)) -[GOOD] (define-fun s30 () Int (- s28 s5)) -[GOOD] (define-fun s31 () (Seq Int) (seq.extract s27 s5 s30)) -[GOOD] (define-fun s32 () Int (seq.len s31)) -[GOOD] (define-fun s33 () Bool (= s2 s32)) -[GOOD] (define-fun s34 () Int (- s32 s5)) -[GOOD] (define-fun s35 () (Seq Int) (seq.extract s31 s5 s34)) -[GOOD] (define-fun s36 () Int (seq.len s35)) -[GOOD] (define-fun s37 () Bool (= s2 s36)) -[GOOD] (define-fun s38 () Int (- s36 s5)) -[GOOD] (define-fun s39 () (Seq Int) (seq.extract s35 s5 s38)) -[GOOD] (define-fun s40 () Int (seq.len s39)) -[GOOD] (define-fun s41 () Bool (= s2 s40)) -[GOOD] (define-fun s42 () Int (seq.nth s39 s2)) -[GOOD] (define-fun s43 () (Seq Int) (seq.unit s42)) -[GOOD] (define-fun s44 () (Seq Int) (ite s41 s4 s43)) -[GOOD] (define-fun s45 () Int (seq.nth s35 s2)) -[GOOD] (define-fun s46 () (Seq Int) (seq.unit s45)) -[GOOD] (define-fun s47 () (Seq Int) (seq.++ s44 s46)) -[GOOD] (define-fun s48 () (Seq Int) (ite s37 s4 s47)) -[GOOD] (define-fun s49 () Int (seq.nth s31 s2)) -[GOOD] (define-fun s50 () (Seq Int) (seq.unit s49)) -[GOOD] (define-fun s51 () (Seq Int) (seq.++ s48 s50)) -[GOOD] (define-fun s52 () (Seq Int) (ite s33 s4 s51)) -[GOOD] (define-fun s53 () Int (seq.nth s27 s2)) -[GOOD] (define-fun s54 () (Seq Int) (seq.unit s53)) -[GOOD] (define-fun s55 () (Seq Int) (seq.++ s52 s54)) -[GOOD] (define-fun s56 () (Seq Int) (ite s29 s4 s55)) -[GOOD] (define-fun s57 () Int (seq.nth s23 s2)) -[GOOD] (define-fun s58 () (Seq Int) (seq.unit s57)) -[GOOD] (define-fun s59 () (Seq Int) (seq.++ s56 s58)) -[GOOD] (define-fun s60 () (Seq Int) (ite s25 s4 s59)) -[GOOD] (define-fun s61 () Int (seq.nth s19 s2)) -[GOOD] (define-fun s62 () (Seq Int) (seq.unit s61)) -[GOOD] (define-fun s63 () (Seq Int) (seq.++ s60 s62)) -[GOOD] (define-fun s64 () (Seq Int) (ite s21 s4 s63)) -[GOOD] (define-fun s65 () Int (seq.nth s15 s2)) -[GOOD] (define-fun s66 () (Seq Int) (seq.unit s65)) -[GOOD] (define-fun s67 () (Seq Int) (seq.++ s64 s66)) -[GOOD] (define-fun s68 () (Seq Int) (ite s17 s4 s67)) -[GOOD] (define-fun s69 () Int (seq.nth s11 s2)) -[GOOD] (define-fun s70 () (Seq Int) (seq.unit s69)) -[GOOD] (define-fun s71 () (Seq Int) (seq.++ s68 s70)) -[GOOD] (define-fun s72 () (Seq Int) (ite s13 s4 s71)) -[GOOD] (define-fun s73 () Int (seq.nth s7 s2)) -[GOOD] (define-fun s74 () (Seq Int) (seq.unit s73)) -[GOOD] (define-fun s75 () (Seq Int) (seq.++ s72 s74)) -[GOOD] (define-fun s76 () (Seq Int) (ite s9 s4 s75)) -[GOOD] (define-fun s77 () Int (seq.nth s0 s2)) -[GOOD] (define-fun s78 () (Seq Int) (seq.unit s77)) -[GOOD] (define-fun s79 () (Seq Int) (seq.++ s76 s78)) -[GOOD] (define-fun s80 () (Seq Int) (ite s3 s4 s79)) -[GOOD] (define-fun s81 () (Seq Int) (seq.++ s74 s78)) -[GOOD] (define-fun s82 () (Seq Int) (seq.++ s70 s81)) -[GOOD] (define-fun s83 () (Seq Int) (seq.++ s66 s82)) -[GOOD] (define-fun s84 () (Seq Int) (seq.++ s62 s83)) -[GOOD] (define-fun s85 () (Seq Int) (seq.++ s58 s84)) -[GOOD] (define-fun s86 () (Seq Int) (seq.++ s54 s85)) -[GOOD] (define-fun s87 () (Seq Int) (seq.++ s50 s86)) -[GOOD] (define-fun s88 () (Seq Int) (seq.++ s46 s87)) -[GOOD] (define-fun s89 () (Seq Int) (seq.++ s43 s88)) -[GOOD] (define-fun s90 () (Seq Int) (ite s41 s88 s89)) -[GOOD] (define-fun s91 () (Seq Int) (ite s37 s87 s90)) -[GOOD] (define-fun s92 () (Seq Int) (ite s33 s86 s91)) -[GOOD] (define-fun s93 () (Seq Int) (ite s29 s85 s92)) -[GOOD] (define-fun s94 () (Seq Int) (ite s25 s84 s93)) -[GOOD] (define-fun s95 () (Seq Int) (ite s21 s83 s94)) -[GOOD] (define-fun s96 () (Seq Int) (ite s17 s82 s95)) -[GOOD] (define-fun s97 () (Seq Int) (ite s13 s81 s96)) -[GOOD] (define-fun s98 () (Seq Int) (ite s9 s78 s97)) -[GOOD] (define-fun s99 () (Seq Int) (ite s3 s4 s98)) -[GOOD] (define-fun s100 () Bool (distinct s80 s99)) -[GOOD] ; --- delayedEqualities --- -[GOOD] ; --- formula --- -[GOOD] (assert s100) -[SEND] (check-sat) -[RECV] unsat -*** Solver : Z3 -*** Exit code: ExitSuccess 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 @@ -40,27 +40,27 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (s0)) -[RECV] ((s0 (store ((as const (Array E Bool)) false) A true))) +[RECV] ((s0 (store ((as const (Array E Bool)) false) B true))) [GOOD] (push 1) -[GOOD] (define-fun s3 () (Array E Bool) (store ((as const (Array E Bool)) false) A true)) +[GOOD] (define-fun s3 () (Array E Bool) (store ((as const (Array E Bool)) false) B true)) [GOOD] (define-fun s4 () Bool (distinct s0 s3)) [GOOD] (assert s4) Fast allSat, Looking for solution 3 [SEND] (check-sat) [RECV] sat [SEND] (get-value (s0)) -[RECV] ((s0 (store ((as const (Array E Bool)) false) B true))) +[RECV] ((s0 (store ((as const (Array E Bool)) false) A true))) [GOOD] (push 1) -[GOOD] (define-fun s5 () (Array E Bool) (store ((as const (Array E Bool)) false) B true)) +[GOOD] (define-fun s5 () (Array E Bool) (store ((as const (Array E Bool)) false) A true)) [GOOD] (define-fun s6 () Bool (distinct s0 s5)) [GOOD] (assert s6) 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) B true))) +[RECV] ((s0 (store (store ((as const (Array E Bool)) false) C true) A true))) [GOOD] (push 1) -[GOOD] (define-fun s7 () (Array E Bool) (store (store ((as const (Array E Bool)) false) C true) B true)) +[GOOD] (define-fun s7 () (Array E Bool) (store (store ((as const (Array E Bool)) false) C true) A true)) [GOOD] (define-fun s8 () Bool (distinct s0 s7)) [GOOD] (assert s8) Fast allSat, Looking for solution 5 @@ -85,18 +85,18 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (s0)) -[RECV] ((s0 (store ((as const (Array E Bool)) true) B false))) +[RECV] ((s0 (store (store ((as const (Array E Bool)) false) C true) B true))) [GOOD] (push 1) -[GOOD] (define-fun s13 () (Array E Bool) (store ((as const (Array E Bool)) true) B false)) +[GOOD] (define-fun s13 () (Array E Bool) (store (store ((as const (Array E Bool)) false) C true) B true)) [GOOD] (define-fun s14 () Bool (distinct s0 s13)) [GOOD] (assert s14) Fast allSat, Looking for solution 8 [SEND] (check-sat) [RECV] sat [SEND] (get-value (s0)) -[RECV] ((s0 (store (store ((as const (Array E Bool)) true) B false) A false))) +[RECV] ((s0 (store ((as const (Array E Bool)) false) C true))) [GOOD] (push 1) -[GOOD] (define-fun s15 () (Array E Bool) (store (store ((as const (Array E Bool)) true) B false) A false)) +[GOOD] (define-fun s15 () (Array E Bool) (store ((as const (Array E Bool)) false) C true)) [GOOD] (define-fun s16 () Bool (distinct s0 s15)) [GOOD] (assert s16) Fast allSat, Looking for solution 9 @@ -115,19 +115,19 @@ FINAL: Solution #1: - s0 = U - {A,B} :: {E} + s0 = {C} :: {E} Solution #2: - s0 = U - {B} :: {E} + s0 = {B,C} :: {E} Solution #3: s0 = {A,B} :: {E} Solution #4: s0 = U :: {E} Solution #5: - s0 = {B,C} :: {E} + s0 = {A,C} :: {E} Solution #6: - s0 = {B} :: {E} -Solution #7: s0 = {A} :: {E} +Solution #7: + s0 = {B} :: {E} Solution #8: s0 = {} :: {E} Found 8 different solutions. diff --git a/SBVTestSuite/GoldFiles/set_uninterp2.gold b/SBVTestSuite/GoldFiles/set_uninterp2.gold --- a/SBVTestSuite/GoldFiles/set_uninterp2.gold +++ b/SBVTestSuite/GoldFiles/set_uninterp2.gold @@ -32,12 +32,12 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (s0)) -[RECV] ((s0 (store ((as const (Array E Bool)) false) A true))) +[RECV] ((s0 (store ((as const (Array E Bool)) false) B true))) [SEND] (get-value (s1)) [RECV] ((s1 ((as const (Array E Bool)) false))) *** Solver : Z3 *** Exit code: ExitSuccess FINAL: -({A},{}) +({B},{}) DONE! diff --git a/SBVTestSuite/GoldFiles/sort.gold b/SBVTestSuite/GoldFiles/sort.gold deleted file mode 100644 --- a/SBVTestSuite/GoldFiles/sort.gold +++ /dev/null @@ -1,169 +0,0 @@ -** 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-option :pp.max_depth 4294967295) -[GOOD] (set-option :pp.min_alias_size 4294967295) -[GOOD] (set-option :model.inline_def true ) -[GOOD] (set-logic ALL) ; has unbounded values, using catch-all. -[GOOD] ; --- uninterpreted sorts --- -[GOOD] ; --- tuples --- -[GOOD] ; --- sums --- -[GOOD] ; --- literal constants --- -[GOOD] (define-fun s12 () Int 0) -[GOOD] (define-fun s14 () (Seq Int) (as seq.empty (Seq Int))) -[GOOD] (define-fun s15 () Int 1) -[GOOD] ; --- top level inputs --- -[GOOD] (declare-fun s0 () Int) ; tracks user variable "a" -[GOOD] (declare-fun s1 () Int) ; tracks user variable "b" -[GOOD] (declare-fun s2 () Int) ; tracks user variable "c" -[GOOD] ; --- constant tables --- -[GOOD] ; --- non-constant tables --- -[GOOD] ; --- uninterpreted constants --- -[GOOD] ; --- user defined functions --- -[GOOD] ; --- assignments --- -[GOOD] (define-fun s3 () Bool (<= s0 s1)) -[GOOD] (define-fun s4 () Bool (<= s1 s2)) -[GOOD] (define-fun s5 () Bool (and s3 s4)) -[GOOD] (define-fun s6 () (Seq Int) (seq.unit s0)) -[GOOD] (define-fun s7 () (Seq Int) (seq.unit s1)) -[GOOD] (define-fun s8 () (Seq Int) (seq.unit s2)) -[GOOD] (define-fun s9 () (Seq Int) (seq.++ s7 s8)) -[GOOD] (define-fun s10 () (Seq Int) (seq.++ s6 s9)) -[GOOD] (define-fun s11 () Int (seq.len s10)) -[GOOD] (define-fun s13 () Bool (= s11 s12)) -[GOOD] (define-fun s16 () Int (- s11 s15)) -[GOOD] (define-fun s17 () (Seq Int) (seq.extract s10 s15 s16)) -[GOOD] (define-fun s18 () Int (seq.len s17)) -[GOOD] (define-fun s19 () Bool (= s12 s18)) -[GOOD] (define-fun s20 () Int (- s18 s15)) -[GOOD] (define-fun s21 () (Seq Int) (seq.extract s17 s15 s20)) -[GOOD] (define-fun s22 () Int (seq.len s21)) -[GOOD] (define-fun s23 () Bool (= s12 s22)) -[GOOD] (define-fun s24 () Int (seq.nth s21 s12)) -[GOOD] (define-fun s25 () (Seq Int) (seq.unit s24)) -[GOOD] (define-fun s26 () (Seq Int) (ite s23 s14 s25)) -[GOOD] (define-fun s27 () Int (seq.len s26)) -[GOOD] (define-fun s28 () Bool (= s12 s27)) -[GOOD] (define-fun s29 () Int (seq.nth s17 s12)) -[GOOD] (define-fun s30 () (Seq Int) (seq.unit s29)) -[GOOD] (define-fun s31 () Int (seq.nth s26 s12)) -[GOOD] (define-fun s32 () Bool (< s29 s31)) -[GOOD] (define-fun s33 () (Seq Int) (seq.unit s31)) -[GOOD] (define-fun s34 () Int (- s27 s15)) -[GOOD] (define-fun s35 () (Seq Int) (seq.extract s26 s15 s34)) -[GOOD] (define-fun s36 () (Seq Int) (seq.++ s33 s35)) -[GOOD] (define-fun s37 () (Seq Int) (seq.++ s30 s36)) -[GOOD] (define-fun s38 () Int (seq.len s35)) -[GOOD] (define-fun s39 () Bool (= s12 s38)) -[GOOD] (define-fun s40 () Int (seq.nth s35 s12)) -[GOOD] (define-fun s41 () Bool (< s29 s40)) -[GOOD] (define-fun s42 () (Seq Int) (seq.unit s40)) -[GOOD] (define-fun s43 () Int (- s38 s15)) -[GOOD] (define-fun s44 () (Seq Int) (seq.extract s35 s15 s43)) -[GOOD] (define-fun s45 () (Seq Int) (seq.++ s42 s44)) -[GOOD] (define-fun s46 () (Seq Int) (seq.++ s30 s45)) -[GOOD] (define-fun s47 () Int (seq.len s44)) -[GOOD] (define-fun s48 () Bool (= s12 s47)) -[GOOD] (define-fun s49 () Int (seq.nth s44 s12)) -[GOOD] (define-fun s50 () Bool (< s29 s49)) -[GOOD] (define-fun s51 () (Seq Int) (seq.unit s49)) -[GOOD] (define-fun s52 () Int (- s47 s15)) -[GOOD] (define-fun s53 () (Seq Int) (seq.extract s44 s15 s52)) -[GOOD] (define-fun s54 () (Seq Int) (seq.++ s51 s53)) -[GOOD] (define-fun s55 () (Seq Int) (seq.++ s30 s54)) -[GOOD] (define-fun s56 () (Seq Int) (seq.++ s51 s30)) -[GOOD] (define-fun s57 () (Seq Int) (ite s50 s55 s56)) -[GOOD] (define-fun s58 () (Seq Int) (ite s48 s30 s57)) -[GOOD] (define-fun s59 () (Seq Int) (seq.++ s42 s58)) -[GOOD] (define-fun s60 () (Seq Int) (ite s41 s46 s59)) -[GOOD] (define-fun s61 () (Seq Int) (ite s39 s30 s60)) -[GOOD] (define-fun s62 () (Seq Int) (seq.++ s33 s61)) -[GOOD] (define-fun s63 () (Seq Int) (ite s32 s37 s62)) -[GOOD] (define-fun s64 () (Seq Int) (ite s28 s30 s63)) -[GOOD] (define-fun s65 () (Seq Int) (ite s19 s14 s64)) -[GOOD] (define-fun s66 () Int (seq.len s65)) -[GOOD] (define-fun s67 () Bool (= s12 s66)) -[GOOD] (define-fun s68 () Int (seq.nth s10 s12)) -[GOOD] (define-fun s69 () (Seq Int) (seq.unit s68)) -[GOOD] (define-fun s70 () Int (seq.nth s65 s12)) -[GOOD] (define-fun s71 () Bool (< s68 s70)) -[GOOD] (define-fun s72 () (Seq Int) (seq.unit s70)) -[GOOD] (define-fun s73 () Int (- s66 s15)) -[GOOD] (define-fun s74 () (Seq Int) (seq.extract s65 s15 s73)) -[GOOD] (define-fun s75 () (Seq Int) (seq.++ s72 s74)) -[GOOD] (define-fun s76 () (Seq Int) (seq.++ s69 s75)) -[GOOD] (define-fun s77 () Int (seq.len s74)) -[GOOD] (define-fun s78 () Bool (= s12 s77)) -[GOOD] (define-fun s79 () Int (seq.nth s74 s12)) -[GOOD] (define-fun s80 () Bool (< s68 s79)) -[GOOD] (define-fun s81 () (Seq Int) (seq.unit s79)) -[GOOD] (define-fun s82 () Int (- s77 s15)) -[GOOD] (define-fun s83 () (Seq Int) (seq.extract s74 s15 s82)) -[GOOD] (define-fun s84 () (Seq Int) (seq.++ s81 s83)) -[GOOD] (define-fun s85 () (Seq Int) (seq.++ s69 s84)) -[GOOD] (define-fun s86 () Int (seq.len s83)) -[GOOD] (define-fun s87 () Bool (= s12 s86)) -[GOOD] (define-fun s88 () Int (seq.nth s83 s12)) -[GOOD] (define-fun s89 () Bool (< s68 s88)) -[GOOD] (define-fun s90 () (Seq Int) (seq.unit s88)) -[GOOD] (define-fun s91 () Int (- s86 s15)) -[GOOD] (define-fun s92 () (Seq Int) (seq.extract s83 s15 s91)) -[GOOD] (define-fun s93 () (Seq Int) (seq.++ s90 s92)) -[GOOD] (define-fun s94 () (Seq Int) (seq.++ s69 s93)) -[GOOD] (define-fun s95 () (Seq Int) (seq.++ s90 s69)) -[GOOD] (define-fun s96 () (Seq Int) (ite s89 s94 s95)) -[GOOD] (define-fun s97 () (Seq Int) (ite s87 s69 s96)) -[GOOD] (define-fun s98 () (Seq Int) (seq.++ s81 s97)) -[GOOD] (define-fun s99 () (Seq Int) (ite s80 s85 s98)) -[GOOD] (define-fun s100 () (Seq Int) (ite s78 s69 s99)) -[GOOD] (define-fun s101 () (Seq Int) (seq.++ s72 s100)) -[GOOD] (define-fun s102 () (Seq Int) (ite s71 s76 s101)) -[GOOD] (define-fun s103 () (Seq Int) (ite s67 s69 s102)) -[GOOD] (define-fun s104 () (Seq Int) (ite s13 s14 s103)) -[GOOD] (define-fun s105 () Bool (= s10 s104)) -[GOOD] (define-fun s106 () Bool (=> s5 s105)) -[GOOD] (define-fun s107 () Bool (<= s0 s2)) -[GOOD] (define-fun s108 () Bool (<= s2 s1)) -[GOOD] (define-fun s109 () Bool (and s107 s108)) -[GOOD] (define-fun s110 () (Seq Int) (seq.++ s8 s7)) -[GOOD] (define-fun s111 () (Seq Int) (seq.++ s6 s110)) -[GOOD] (define-fun s112 () Bool (= s104 s111)) -[GOOD] (define-fun s113 () Bool (=> s109 s112)) -[GOOD] (define-fun s114 () Bool (<= s1 s0)) -[GOOD] (define-fun s115 () Bool (and s107 s114)) -[GOOD] (define-fun s116 () (Seq Int) (seq.++ s6 s8)) -[GOOD] (define-fun s117 () (Seq Int) (seq.++ s7 s116)) -[GOOD] (define-fun s118 () Bool (= s104 s117)) -[GOOD] (define-fun s119 () Bool (=> s115 s118)) -[GOOD] (define-fun s120 () Bool (<= s2 s0)) -[GOOD] (define-fun s121 () Bool (and s4 s120)) -[GOOD] (define-fun s122 () (Seq Int) (seq.++ s8 s6)) -[GOOD] (define-fun s123 () (Seq Int) (seq.++ s7 s122)) -[GOOD] (define-fun s124 () Bool (= s104 s123)) -[GOOD] (define-fun s125 () Bool (=> s121 s124)) -[GOOD] (define-fun s126 () Bool (and s3 s120)) -[GOOD] (define-fun s127 () (Seq Int) (seq.++ s6 s7)) -[GOOD] (define-fun s128 () (Seq Int) (seq.++ s8 s127)) -[GOOD] (define-fun s129 () Bool (= s104 s128)) -[GOOD] (define-fun s130 () Bool (=> s126 s129)) -[GOOD] (define-fun s131 () Bool (and s108 s114)) -[GOOD] (define-fun s132 () (Seq Int) (seq.++ s7 s6)) -[GOOD] (define-fun s133 () (Seq Int) (seq.++ s8 s132)) -[GOOD] (define-fun s134 () Bool (= s104 s133)) -[GOOD] (define-fun s135 () Bool (=> s131 s134)) -[GOOD] ; --- delayedEqualities --- -[GOOD] ; --- formula --- -[GOOD] (assert s106) -[GOOD] (assert s113) -[GOOD] (assert s119) -[GOOD] (assert s125) -[GOOD] (assert s130) -[GOOD] (assert s135) -[SEND] (check-sat) -[RECV] sat -*** Solver : Z3 -*** Exit code: ExitSuccess 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 @@ -11,13 +11,14 @@ [GOOD] ; --- sums --- [GOOD] ; --- literal constants --- [GOOD] ; --- top level inputs --- +[GOOD] (declare-fun s0 () Bool) ; tracks user variable "__internal_sbv_s0" [GOOD] ; --- constant tables --- [GOOD] ; --- non-constant tables --- [GOOD] ; --- uninterpreted constants --- [GOOD] (declare-fun q1 (Bool) Bool) [GOOD] ; --- user defined functions --- [GOOD] ; --- assignments --- -[GOOD] (define-fun s0 () Bool (q1 false)) +[GOOD] (define-fun s1 () Bool (q1 s0)) [GOOD] ; --- delayedEqualities --- [GOOD] ; --- formula --- *** Checking Satisfiability, all 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 @@ -11,13 +11,15 @@ [GOOD] ; --- sums --- [GOOD] ; --- literal constants --- [GOOD] ; --- top level inputs --- +[GOOD] (declare-fun s0 () Bool) ; tracks user variable "__internal_sbv_s0" +[GOOD] (declare-fun s1 () Bool) ; tracks user variable "__internal_sbv_s1" [GOOD] ; --- constant tables --- [GOOD] ; --- non-constant tables --- [GOOD] ; --- uninterpreted constants --- [GOOD] (declare-fun q2 (Bool Bool) Bool) [GOOD] ; --- user defined functions --- [GOOD] ; --- assignments --- -[GOOD] (define-fun s0 () Bool (q2 false false)) +[GOOD] (define-fun s2 () Bool (q2 s0 s1)) [GOOD] ; --- delayedEqualities --- [GOOD] ; --- formula --- *** Checking Satisfiability, all 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 @@ -11,6 +11,9 @@ [GOOD] ; --- sums --- [GOOD] ; --- literal constants --- [GOOD] ; --- top level inputs --- +[GOOD] (declare-fun s0 () Bool) ; tracks user variable "__internal_sbv_s0" +[GOOD] (declare-fun s2 () Bool) ; tracks user variable "__internal_sbv_s2" +[GOOD] (declare-fun s3 () Bool) ; tracks user variable "__internal_sbv_s3" [GOOD] ; --- constant tables --- [GOOD] ; --- non-constant tables --- [GOOD] ; --- uninterpreted constants --- @@ -18,8 +21,8 @@ [GOOD] (declare-fun q2 (Bool Bool) Bool) [GOOD] ; --- user defined functions --- [GOOD] ; --- assignments --- -[GOOD] (define-fun s0 () Bool (q1 false)) -[GOOD] (define-fun s1 () Bool (q2 false false)) +[GOOD] (define-fun s1 () Bool (q1 s0)) +[GOOD] (define-fun s4 () Bool (q2 s2 s3)) [GOOD] ; --- delayedEqualities --- [GOOD] ; --- formula --- *** Checking Satisfiability, all solutions.. diff --git a/SBVTestSuite/GoldFiles/unint-axioms-empty.gold b/SBVTestSuite/GoldFiles/unint-axioms-empty.gold --- a/SBVTestSuite/GoldFiles/unint-axioms-empty.gold +++ b/SBVTestSuite/GoldFiles/unint-axioms-empty.gold @@ -12,10 +12,11 @@ [GOOD] ; --- tuples --- [GOOD] ; --- sums --- [GOOD] ; --- literal constants --- -[GOOD] (define-fun s2 () Thing Thing_witness) [GOOD] ; --- top level inputs --- -[GOOD] (declare-fun s4 () Thing) +[GOOD] (declare-fun s2 () Thing) ; tracks user variable "__internal_sbv_s2" +[GOOD] (declare-fun s3 () Thing) ; tracks user variable "__internal_sbv_s3" [GOOD] (declare-fun s5 () Thing) +[GOOD] (declare-fun s6 () Thing) [GOOD] ; --- constant tables --- [GOOD] ; --- non-constant tables --- [GOOD] ; --- uninterpreted constants --- @@ -29,15 +30,15 @@ (let ((l1_s2 (thingMerge l1_s0 l1_s1))) (let ((l1_s3 (distinct l1_s0 l1_s2))) l1_s3)))) -[GOOD] (define-fun s3 () Thing (thingMerge s2 s2)) -[GOOD] (define-fun s6 () Bool (= s4 s5)) -[GOOD] (define-fun s7 () Bool (thingCompare s4 s5)) -[GOOD] (define-fun s8 () Bool (=> s6 s7)) +[GOOD] (define-fun s4 () Thing (thingMerge s2 s3)) +[GOOD] (define-fun s7 () Bool (= s5 s6)) +[GOOD] (define-fun s8 () Bool (thingCompare s5 s6)) +[GOOD] (define-fun s9 () Bool (=> s7 s8)) [GOOD] ; --- delayedEqualities --- [GOOD] ; --- formula --- [GOOD] (assert s0) [GOOD] (assert s1) -[GOOD] (assert (not s8)) +[GOOD] (assert (not s9)) [SEND] (check-sat) [RECV] unsat *** Solver : Z3 diff --git a/SBVTestSuite/SBVTest.hs b/SBVTestSuite/SBVTest.hs --- a/SBVTestSuite/SBVTest.hs +++ b/SBVTestSuite/SBVTest.hs @@ -28,7 +28,6 @@ import qualified TestSuite.Basics.Assert import qualified TestSuite.Basics.BasicTests import qualified TestSuite.Basics.BarrelRotate -import qualified TestSuite.Basics.BoundedList import qualified TestSuite.Basics.DynSign import qualified TestSuite.Basics.Exceptions import qualified TestSuite.Basics.EqSym @@ -140,7 +139,6 @@ , TestSuite.Basics.Assert.tests , TestSuite.Basics.BarrelRotate.tests , TestSuite.Basics.BasicTests.tests - , TestSuite.Basics.BoundedList.tests , TestSuite.Basics.DynSign.tests , TestSuite.Basics.EqSym.tests , TestSuite.Basics.Exceptions.testsLocal diff --git a/SBVTestSuite/TestSuite/Arrays/InitVals.hs b/SBVTestSuite/TestSuite/Arrays/InitVals.hs --- a/SBVTestSuite/TestSuite/Arrays/InitVals.hs +++ b/SBVTestSuite/TestSuite/Arrays/InitVals.hs @@ -120,9 +120,9 @@ , goldenCapturedIO "array_misc_26" $ t satWith (.== readArray (listArray [(1/0, 12)] 3 :: SArray Double Integer) (1/0)) , goldenCapturedIO "array_misc_27" $ t satWith (.== readArray (listArray [(1/0, 12)] 3 :: SArray (FloatingPoint 10 4) Integer) (1/0)) - , goldenCapturedIO "array_misc_28" $ t satWith (.== readArray (listArray [(1/0, 12)] 3 :: SArray Float Integer) (-1/0)) - , goldenCapturedIO "array_misc_29" $ t satWith (.== readArray (listArray [(1/0, 12)] 3 :: SArray Double Integer) (-1/0)) - , goldenCapturedIO "array_misc_30" $ t satWith (.== readArray (listArray [(1/0, 12)] 3 :: SArray (FloatingPoint 10 4) Integer) (-1/0)) + , goldenCapturedIO "array_misc_28" $ t satWith (.== readArray (listArray [(1/0, 12)] 3 :: SArray Float Integer) (-(1/0))) + , goldenCapturedIO "array_misc_29" $ t satWith (.== readArray (listArray [(1/0, 12)] 3 :: SArray Double Integer) (-(1/0))) + , goldenCapturedIO "array_misc_30" $ t satWith (.== readArray (listArray [(1/0, 12)] 3 :: SArray (FloatingPoint 10 4) Integer) (-(1/0))) , goldenCapturedIO "array_misc_31" $ t proveWith (listArray [(1, 2), (3, 4)] 5 .== listArray [(3 :: Integer, 4), (1, 2)] (5 :: Integer)) , goldenCapturedIO "array_misc_32" $ t proveWith (listArray [(1, 2), (3, 4)] 5 .== listArray [(3 :: Integer, 4), (1, 2)] (5 :: Double)) diff --git a/SBVTestSuite/TestSuite/Basics/BoundedList.hs b/SBVTestSuite/TestSuite/Basics/BoundedList.hs deleted file mode 100644 --- a/SBVTestSuite/TestSuite/Basics/BoundedList.hs +++ /dev/null @@ -1,201 +0,0 @@ ------------------------------------------------------------------------------ --- | --- Module : TestSuite.Basics.BoundedList --- Copyright : (c) Joel Burget --- License : BSD3 --- Maintainer: erkokl@gmail.com --- Stability : experimental --- --- Test the bounded sequence/list functions. ------------------------------------------------------------------------------ - -{-# LANGUAGE FlexibleContexts #-} -{-# LANGUAGE GeneralizedNewtypeDeriving #-} -{-# LANGUAGE OverloadedLists #-} -{-# LANGUAGE ScopedTypeVariables #-} - -{-# OPTIONS_GHC -Wall -Werror #-} - -module TestSuite.Basics.BoundedList(tests) where - -import Data.SBV.Control -import Utils.SBVTestFramework - -import Prelude hiding ((!!)) -import Data.SBV.List ((.:), (!!)) -import qualified Data.SBV.List as L -import qualified Data.SBV.Tools.BoundedList as BL - -import Control.Monad (unless) -import Control.Monad.State (MonadState(..), State, modify, runState) - --- | Flag to mark a failed computation -newtype Failure = Failure SBool - deriving (Mergeable, EqSymbolic) - --- | Evaluation monad with failure -newtype Eval a = Eval { unEval :: State Failure a } - deriving (Functor, Applicative, Monad, MonadState Failure) - -runEval :: Eval a -> (a, Failure) -runEval (Eval eval) = runState eval (Failure sFalse) - -instance Mergeable a => Mergeable (Eval a) where - symbolicMerge force test left right = Eval $ state $ \s0 -> - let (resL, sL) = runState (unEval left) s0 - (resR, sR) = runState (unEval right) s0 - in ( symbolicMerge force test resL resR - , symbolicMerge force test sL sR - ) - -markFailure :: SBool -> Eval () -markFailure failure = modify (\(Failure b) -> Failure (b .|| failure)) - --- Test suite -tests :: TestTree -tests = - testGroup "Basics.BoundedList" [ - goldenCapturedIO "concreteFoldr" $ \rf -> checkWith z3{redirectVerbose=Just rf} concreteFoldrSat Sat - , goldenCapturedIO "concreteFoldl" $ \rf -> checkWith z3{redirectVerbose=Just rf} concreteFoldlSat Sat - , goldenCapturedIO "foldrAB1" $ \rf -> checkWith z3{redirectVerbose=Just rf} (foldrAB 1) Unsat - , goldenCapturedIO "foldrAB2" $ \rf -> checkWith z3{redirectVerbose=Just rf} (foldrAB 2) Sat - , goldenCapturedIO "foldrAB3" $ \rf -> checkWith z3{redirectVerbose=Just rf} (foldrAB 3) Sat - , goldenCapturedIO "foldlABC1" $ \rf -> checkWith z3{redirectVerbose=Just rf} (foldlABC 1) Unsat - , goldenCapturedIO "foldlABC2" $ \rf -> checkWith z3{redirectVerbose=Just rf} (foldlABC 2) Unsat - , goldenCapturedIO "foldlABC3" $ \rf -> checkWith z3{redirectVerbose=Just rf} (foldlABC 3) Sat - , goldenCapturedIO "concreteReverse" $ \rf -> checkWith z3{redirectVerbose=Just rf} concreteReverseSat Sat - , goldenCapturedIO "reverse" $ \rf -> checkWith z3{redirectVerbose=Just rf} reverseSat Sat - , goldenCapturedIO "reverseAlt10" $ \rf -> checkWith z3{redirectVerbose=Just rf} (reverseAlt 10) Unsat - , goldenCapturedIO "concreteSort" $ \rf -> checkWith z3{redirectVerbose=Just rf} concreteSortSat Sat - , goldenCapturedIO "sort" $ \rf -> checkWith z3{redirectVerbose=Just rf} sortSat Sat - , goldenCapturedIO "mapWithFailure" $ \rf -> checkWith z3{redirectVerbose=Just rf} mapWithFailure Sat - , goldenCapturedIO "mapNoFailure" $ \rf -> checkWith z3{redirectVerbose=Just rf} mapNoFailure Unsat - , goldenCapturedIO "maxlWithFailure" $ \rf -> checkWith z3{redirectVerbose=Just rf} maxlWithFailure Sat - , goldenCapturedIO "maxrWithFailure" $ \rf -> checkWith z3{redirectVerbose=Just rf} maxrWithFailure Sat - ] - -checkWith :: SMTConfig -> Symbolic () -> CheckSatResult -> IO () -checkWith cfg props csExpected = runSMTWith cfg{verbose=True} $ do - _ <- props - query $ do cs <- checkSat - unless (cs == csExpected) $ - case cs of - Unsat -> error $ "Failed! Expected " ++ show csExpected ++ ", got Unsat" - DSat{} -> error $ "Failed! Expected " ++ show csExpected ++ ", got delta-sat" - Sat -> getModel >>= \r -> error $ "Failed! Expected " ++ show csExpected ++ ", got Sat:\n" ++ show (SatResult (Satisfiable cfg r)) - Unk -> getUnknownReason >>= \r -> error $ "Failed! Expected " ++ show csExpected ++ ", got Unk:\n" ++ show r - -concreteFoldrSat :: Symbolic () -concreteFoldrSat = constrain $ BL.bfoldr 3 (+) 0 [1..3] .== (6 :: SInteger) - -concreteFoldlSat :: Symbolic () -concreteFoldlSat = constrain $ BL.bfoldl 10 (+) 0 [1..3] .== (6 :: SInteger) - --- unsatisfiable at bound = 1, satisfiable at bound = 2 or bound = 3 -foldrAB :: Int -> Symbolic () -foldrAB bound = do - [a, b] <- sIntegers ["a", "b"] - constrain $ a .> 0 - constrain $ b .> 0 - constrain $ BL.bfoldr bound (+) 0 (L.implode [a, b]) .== a + b - --- unsatisfiable at bound = 1 or bound = 2, satisfiable at bound = 3 -foldlABC :: Int -> Symbolic () -foldlABC bound = do - [a, b, c] <- sIntegers ["a", "b", "c"] - constrain $ a .> 0 - constrain $ b .> 0 - constrain $ c .> 0 - constrain $ BL.bfoldr bound (+) 0 (L.implode [a, b, c]) .== a + b + c - -concreteReverseSat :: Symbolic () -concreteReverseSat = constrain $ BL.breverse 10 [1..10] .== ([10,9..1] :: SList Integer) - -reverseSat :: Symbolic () -reverseSat = do - abcd <- sIntegers ["a", "b", "c", "d"] - constrain $ BL.breverse 10 (L.implode abcd) .== L.implode (reverse abcd) - -reverseAlt :: Int -> Symbolic () -reverseAlt i = do - xs <- sList "xs" - - -- Assert the negation; so Unsat response means it's all good! - constrain $ BL.breverse i xs ./= rev i xs ([] :: SList Integer) - where -- classic reverse with accumulator - rev 0 _ sofar = sofar - rev c xs sofar = ite (L.null xs) - sofar - (rev (c-1) (L.tail xs) (L.head xs .: sofar)) - - -concreteSortSat :: Symbolic () -concreteSortSat = constrain $ BL.bsort 10 [5,6,3,8,9,2,1,7,10,4] .== ([1..10] :: SList Integer) - -sortSat :: Symbolic () -sortSat = do [a, b, c] <- sIntegers ["a", "b", "c"] - - let sorted = BL.bsort 3 $ L.implode [a, b, c] - - ordered :: (SInteger, SInteger, SInteger) -> SBool - ordered (x, y, z) = x .<= y .&& y .<= z - - constrain $ ordered (a, b, c) .=> sorted .== L.implode [a, b, c] - constrain $ ordered (a, c, b) .=> sorted .== L.implode [a, c, b] - constrain $ ordered (b, a, c) .=> sorted .== L.implode [b, a, c] - constrain $ ordered (b, c, a) .=> sorted .== L.implode [b, c, a] - constrain $ ordered (c, a, b) .=> sorted .== L.implode [c, a, b] - constrain $ ordered (c, b, a) .=> sorted .== L.implode [c, b, a] - --- | Increment, failing if a value lies outside of [0, 10] -boundedIncr :: SList Integer -> Eval (SList Integer) -boundedIncr = BL.bmapM 10 $ \i -> do - markFailure $ i .< 0 .|| i .> 10 - pure $ i + 1 - --- | Max (based on foldr), failing if a value lies outside of [0, 10] -boundedMaxr :: SList Integer -> Eval SInteger -boundedMaxr = BL.bfoldrM 10 - (\i maxi -> do - markFailure $ i .< 0 .|| i .> 10 - pure $ smax i maxi) - 0 - --- | Max (based on foldl), failing if a value lies outside of [0, 10] -boundedMaxl :: SList Integer -> Eval SInteger -boundedMaxl = BL.bfoldlM 10 - (\maxi i -> do - markFailure $ i .< 0 .|| i .> 10 - pure $ smax i maxi) - 0 - --- the mapping will have failed if one of the resulting values is greater than --- 11 -mapWithFailure :: Symbolic () -mapWithFailure = do - lst <- sList "ints" - let (lst', failure) = runEval $ boundedIncr lst - constrain $ lst' !! 2 .> 11 .=> failure .== Failure sTrue - --- mapping over these values of a, b, and c cannot fail (this is unsat) -mapNoFailure :: Symbolic () -mapNoFailure = do - [a, b, c] <- sIntegers ["a", "b", "c"] - let (_lst', Failure failure) = runEval $ boundedIncr $ L.implode [a, b, c] - constrain $ a + b + c .== 6 - constrain $ a .> 0 .&& b .> 0 .&& c .> 0 - constrain failure - --- boundedMaxl fails if one of the values is too big -maxlWithFailure :: Symbolic () -maxlWithFailure = do - lst <- sList "ints" - let (maxi, Failure failure) = runEval $ boundedMaxl lst - constrain $ maxi .> 10 .=> failure - --- boundedMaxl fails if one of the values is too big -maxrWithFailure :: Symbolic () -maxrWithFailure = do - lst <- sList "ints" - let (maxi, Failure failure) = runEval $ boundedMaxr lst - constrain $ maxi .> 10 .=> failure diff --git a/SBVTestSuite/TestSuite/Basics/Lambda.hs b/SBVTestSuite/TestSuite/Basics/Lambda.hs --- a/SBVTestSuite/TestSuite/Basics/Lambda.hs +++ b/SBVTestSuite/TestSuite/Basics/Lambda.hs @@ -27,7 +27,7 @@ import Prelude hiding((++), map, foldl, foldr, sum, length, zip, zipWith, all, any, concat, filter) import qualified Prelude as P -import Control.Monad (unless) +import Control.Monad (unless, void) import qualified Control.Exception as C import Data.SBV.Control @@ -54,9 +54,9 @@ tests :: TestTree tests = testGroup "Basics.Lambda" $ [ - goldenCapturedIO "lambda01" $ record $ \st -> lambdaStr st (kindOf (Proxy @SInteger)) (2 :: SInteger) - , goldenCapturedIO "lambda02" $ record $ \st -> lambdaStr st (kindOf (Proxy @SInteger)) (\x -> x+1 :: SInteger) - , goldenCapturedIO "lambda03" $ record $ \st -> lambdaStr st (kindOf (Proxy @SInteger)) (\x y -> x+y*2 :: SInteger) + goldenCapturedIO "lambda01" $ record $ \st -> show <$> lambdaStr st TopLevel (kindOf (Proxy @SInteger)) (2 :: SInteger) + , goldenCapturedIO "lambda02" $ record $ \st -> show <$> lambdaStr st TopLevel (kindOf (Proxy @SInteger)) (\x -> x+1 :: SInteger) + , goldenCapturedIO "lambda03" $ record $ \st -> show <$> lambdaStr st TopLevel (kindOf (Proxy @SInteger)) (\x y -> x+y*2 :: SInteger) , goldenCapturedIO "lambda04" $ eval1 [1 .. 3 :: Integer] (map (const sFalse), P.map (const False)) , goldenCapturedIO "lambda05" $ eval1 [1 .. 5 :: Integer] (map (+1) . map (+2), P.map (+1) . P.map (+2)) @@ -65,10 +65,14 @@ , P.map (\x -> P.sum [x ^ i | i <- [1..10 :: Integer]]) ) - , goldenCapturedIO "lambda07" $ eval1 ([[1..5], [1..10], [1..20]] :: [[Integer]]) - ( let sum = foldl (+) 0 in sum . map sum - , P.sum . P.map P.sum - ) + -- no nested lambda's alas; the "map sum" term leads to a nested-lambda, and our current + -- lambda handler isn't smart enough to take care of such nestedness due to firstification + -- We can (hopefully) lift this when SMTLib starts officially supporting higher-order functions + -- and solvers get better at it. + , goldenCapturedIO "lambda07" $ eval1Err ([[1..5], [1..10], [1..20]] :: [[Integer]]) + ( let sum = foldl (+) 0 in sum . map sum + , P.sum . P.map P.sum + ) , goldenCapturedIO "lambda08" $ eval1 [1 .. 5 :: Float] (map (+1), P.map (+1)) , goldenCapturedIO "lambda09" $ eval1 [1 .. 5 :: Int8] (map (+1), P.map (+1)) @@ -80,7 +84,7 @@ , goldenCapturedIO "lambda13" $ eval1 [(x, y) | x <- [1..3], y <- [4..6 :: Integer]] (map (\t -> t^._1 + t^._2), P.map (uncurry (+))) - , goldenCapturedIO "lambda14" $ eval1 [1 .. 5 :: Integer] (mapi (+) 10, P.zipWith (+) [10..]) + , goldenCapturedIO "lambda14" $ eval1 [1 .. 5 :: Integer] (zipWith (+) [10..15], P.zipWith (+) [10..15]) , goldenCapturedIO "lambda15" $ eval1 [1 .. 5 :: Integer] (foldl (+) 0, P.sum) , goldenCapturedIO "lambda16" $ eval1 [1 .. 5 :: Integer] (foldl (*) 1, P.product) @@ -90,8 +94,8 @@ ) , goldenCapturedIO "lambda18" $ eval1 [1 .. 5 :: Integer] - ( foldli (\i b a -> i+b+a) 10 0 - , P.foldl (\b (i, a) -> i+b+a) 0 . P.zip [10..] + ( foldl (\b t -> t^._1 + b + t^._2) 0 . zip [10..15] + , P.foldl (\b (i, a) -> i + b + a) 0 . P.zip [10..15] ) , goldenCapturedIO "lambda19" $ eval1 [1 .. 5 :: Integer] (foldr (+) 0, P.foldr (+) 0) @@ -123,21 +127,21 @@ , goldenCapturedIO "lambda31" $ eval1 [1 .. 10 :: Integer] (filter (\x -> x `sMod` 2 .== 0), P.filter (\x -> x `mod` 2 == 0)) , goldenCapturedIO "lambda32" $ eval1 [1 .. 10 :: Integer] (filter (\x -> x `sMod` 2 ./= 0), P.filter (\x -> x `mod` 2 /= 0)) - , goldenCapturedIO "lambda33" $ record $ \st -> lambdaStr st (kindOf (Proxy @SInt8)) (0 :: SInt8) - , goldenCapturedIO "lambda34" $ record $ \st -> lambdaStr st (kindOf (Proxy @SInt8)) (\x -> x+1 :: SInt8) - , goldenCapturedIO "lambda35" $ record $ \st -> lambdaStr st (kindOf (Proxy @SInt8)) (\x y -> x+y :: SInt8) + , goldenCapturedIO "lambda33" $ record $ \st -> show <$> lambdaStr st TopLevel (kindOf (Proxy @SInt8)) (0 :: SInt8) + , goldenCapturedIO "lambda34" $ record $ \st -> show <$> lambdaStr st TopLevel (kindOf (Proxy @SInt8)) (\x -> x+1 :: SInt8) + , goldenCapturedIO "lambda35" $ record $ \st -> show <$> lambdaStr st TopLevel (kindOf (Proxy @SInt8)) (\x y -> x+y :: SInt8) , goldenCapturedIO "lambda36" $ record $ \st -> constraintStr st $ \(Forall (_ :: SBool)) -> sTrue , goldenCapturedIO "lambda37" $ record $ \st -> constraintStr st $ \(Forall b) -> sNot b , goldenCapturedIO "lambda38" $ record $ \st -> constraintStr st $ \(Forall x) (Forall y) -> x .== (0 :: SInteger) .|| y - , goldenCapturedIO "lambda40" $ record $ \st -> namedLambdaStr st "lambda40" t_i (0 :: SInteger) - , goldenCapturedIO "lambda41" $ record $ \st -> namedLambdaStr st "lambda41" t_i2i (\x -> x+1 :: SInteger) - , goldenCapturedIO "lambda42" $ record $ \st -> namedLambdaStr st "lambda42" t_ii2i (\x y -> x+y :: SInteger) + , goldenCapturedIO "lambda40" $ record $ \st -> namedLambdaStr TopLevel st "lambda40" t_i (0 :: SInteger) + , goldenCapturedIO "lambda41" $ record $ \st -> namedLambdaStr TopLevel st "lambda41" t_i2i (\x -> x+1 :: SInteger) + , goldenCapturedIO "lambda42" $ record $ \st -> namedLambdaStr TopLevel st "lambda42" t_ii2i (\x y -> x+y :: SInteger) - , goldenCapturedIO "lambda43" $ record $ \st -> namedLambdaStr st "lambda43" t_w32 (0 :: SWord32) - , goldenCapturedIO "lambda44" $ record $ \st -> namedLambdaStr st "lambda44" t_w32_w32 (\x -> x+1 :: SWord32) - , goldenCapturedIO "lambda45" $ record $ \st -> namedLambdaStr st "lambda45" t_w32_w32_w32 (\x y -> x+y :: SWord32) + , goldenCapturedIO "lambda43" $ record $ \st -> namedLambdaStr TopLevel st "lambda43" t_w32 (0 :: SWord32) + , goldenCapturedIO "lambda44" $ record $ \st -> namedLambdaStr TopLevel st "lambda44" t_w32_w32 (\x -> x+1 :: SWord32) + , goldenCapturedIO "lambda45" $ record $ \st -> namedLambdaStr TopLevel st "lambda45" t_w32_w32_w32 (\x y -> x+y :: SWord32) , goldenCapturedIO "lambda46" $ runSat ((.== 5) . add1) @@ -231,6 +235,7 @@ , goldenCapturedIO "lambda79" $ \f -> sbv2smt def_t1 >>= writeFile f , goldenCapturedIO "lambda80" $ \f -> sbv2smt def_t2 >>= writeFile f + , goldenCapturedIO "lambda81" $ errorOut freeVar1 ] P.++ qc1 "lambdaQC1" P.sum (foldr (+) (0::SInteger)) P.++ qc2 "lambdaQC2" (+) (smtFunction "sadd" ((+) :: SInteger -> SInteger -> SInteger)) @@ -259,7 +264,7 @@ poI = isPartialOrder "poI" leq record :: (State -> IO String) -> FilePath -> IO () - record gen rf = do st <- mkNewState defaultSMTCfg (LambdaGen 0) + record gen rf = do st <- mkNewState defaultSMTCfg (LambdaGen (Just 0)) appendFile rf . (P.++ "\n") =<< gen st runP b rf = runGen proveWith b rf @@ -311,10 +316,19 @@ Sat -> getModel _ -> error $ "Unexpected output: " P.++ show cs + eval1 :: (SymVal a, SymVal b, Show a, Show b, Eq b) => a -> (SBV a -> SBV b, a -> b) -> FilePath -> IO () -eval1 cArg (sFun, cFun) rf = do m <- runSMTWith z3{verbose=True, redirectVerbose=Just rf} run - appendFile rf ("\nRESULT:\n" P.++ showModel z3 m P.++ "\n") +eval1 cArg sf rf = eval1Gen cArg sf rf z3{verbose=True, redirectVerbose=Just rf} +eval1Err :: (SymVal a, SymVal b, Show a, Show b, Eq b) => a -> (SBV a -> SBV b, a -> b) -> FilePath -> IO () +eval1Err cArg sf rf = void (eval1Gen cArg sf rf z3{verbose=True, redirectVerbose=Just rf}) + `C.catch` \(e::C.SomeException) -> do appendFile rf "CAUGHT EXCEPTION\n\n" + appendFile rf (show e) + +eval1Gen :: (SymVal a, SymVal b, Show a, Show b, Eq b) => a -> (SBV a -> SBV b, a -> b) -> FilePath -> SMTConfig -> IO () +eval1Gen cArg (sFun, cFun) rf cfg = do m <- runSMTWith cfg run + appendFile rf ("\nRESULT:\n" P.++ showModel z3 m P.++ "\n") + where run = do arg <- free_ res <- free_ constrain $ arg .== literal cArg @@ -362,6 +376,19 @@ getModel _ -> error $ "Unexpected output: " P.++ show cs +-- Tests that error out +errorOut :: (SMTConfig -> IO a) -> FilePath -> IO () +errorOut t rf = void (t z3{verbose=True, redirectVerbose=Just rf}) + `C.catch` \(e::C.SomeException) -> do appendFile rf "CAUGHT EXCEPTION\n\n" + appendFile rf (show e) + +-- Don't allow free variables in higher-order functions. Firstification can't handle these. +freeVar1 :: SMTConfig -> IO SatResult +freeVar1 cfg = satWith cfg $ do + zs <- free_ + xs <- free_ + constrain $ xs .== literal [1,2,3::Integer] + pure $ zs .== map (\x -> map (\y -> x+y) (literal [3,4,5])) xs {- HLint ignore module "Use map once" -} {- HLint ignore module "Use sum" -} diff --git a/SBVTestSuite/TestSuite/Basics/UISat.hs b/SBVTestSuite/TestSuite/Basics/UISat.hs --- a/SBVTestSuite/TestSuite/Basics/UISat.hs +++ b/SBVTestSuite/TestSuite/Basics/UISat.hs @@ -14,7 +14,6 @@ module TestSuite.Basics.UISat(tests) where -import Data.SBV.Control import Utils.SBVTestFramework -- Test suite @@ -45,15 +44,15 @@ test1 :: ConstraintSet test1 = do setLogic Logic_ALL - registerUISMTFunction q1 + registerFunction q1 test2 :: ConstraintSet test2 = do setLogic Logic_ALL - registerUISMTFunction q2 + registerFunction q2 test3 :: ConstraintSet test3 = do setLogic Logic_ALL - registerUISMTFunction q1 - registerUISMTFunction q2 + registerFunction q1 + registerFunction q2 {- HLint ignore module "Reduce duplication" -} diff --git a/SBVTestSuite/TestSuite/Queries/UISatEx.hs b/SBVTestSuite/TestSuite/Queries/UISatEx.hs --- a/SBVTestSuite/TestSuite/Queries/UISatEx.hs +++ b/SBVTestSuite/TestSuite/Queries/UISatEx.hs @@ -47,9 +47,8 @@ where qCore = do core let q6 :: SInteger -> SBool q6 = uninterpret "q6" - constrain $ q6 0 .=> q6 0 - query $ do registerUISMTFunction q6 -- Not really necessary, but testing it doesn't break anything - ensureSat + registerFunction q6 + query $ do ensureSat qv1 <- getFunction q1 qv2 <- getFunction q2 qv3 <- getFunction q3 @@ -80,7 +79,7 @@ constrain $ q1 (-3) .== 9 constrain $ q1 x .== x+1 - registerUISMTFunction q2 -- Not really necessary, but testing it doesn't break anything + registerFunction q2 -- Not really necessary, but testing it doesn't break anything constrain $ q2 sTrue 3 .== 5 constrain $ q2 sFalse 7 .== 6 constrain $ q2 sFalse 12 .== 3 diff --git a/SBVTestSuite/TestSuite/Uninterpreted/Axioms.hs b/SBVTestSuite/TestSuite/Uninterpreted/Axioms.hs --- a/SBVTestSuite/TestSuite/Uninterpreted/Axioms.hs +++ b/SBVTestSuite/TestSuite/Uninterpreted/Axioms.hs @@ -62,7 +62,7 @@ p1 :: Symbolic SBool p1 = do constrain $ \(Forall x) -> thingCompare x x constrain $ \(Forall k1) (Forall k2) -> k1 ./= thingMerge k1 k2 - registerUISMTFunction thingMerge + registerFunction thingMerge k1 <- free_ k2 <- free_ return $ k1 .== k2 .=> thingCompare k1 k2 diff --git a/SBVTestSuite/Utils/SBVTestFramework.hs b/SBVTestSuite/Utils/SBVTestFramework.hs --- a/SBVTestSuite/Utils/SBVTestFramework.hs +++ b/SBVTestSuite/Utils/SBVTestFramework.hs @@ -39,7 +39,6 @@ import Control.Monad.Trans (liftIO) import qualified Data.ByteString.Lazy.Char8 as LBC - import System.Directory (removeFile) import Test.Tasty (testGroup, TestTree, TestName) diff --git a/sbv.cabal b/sbv.cabal --- a/sbv.cabal +++ b/sbv.cabal @@ -1,13 +1,13 @@ Cabal-Version: 2.2 Name : sbv -Version : 11.0 +Version : 11.1 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 (Satisfiability Modulo Theories) solvers. -Copyright : Levent Erkok, 2010-2024 +Copyright : Levent Erkok, 2010-2025 License : BSD-3-Clause License-file : LICENSE Stability : Experimental @@ -31,7 +31,6 @@ build-depends : base >= 4.19 && < 5 other-extensions: BangPatterns CPP - ConstrainedClassMethods ConstraintKinds DataKinds DefaultSignatures @@ -72,7 +71,6 @@ TypeApplications TypeFamilies TypeOperators - TypeSynonymInstances UndecidableInstances ViewPatterns @@ -87,12 +85,15 @@ default-language: Haskell2010 build-depends : QuickCheck , array - , async >= 2.2.5 + , async >= 2.2.5 + , bytestring + , base16-bytestring + , cryptohash-sha512 , containers , deepseq , directory , filepath - , libBF >= 0.6.8 + , libBF >= 0.6.8 , mtl , pretty , process @@ -118,10 +119,8 @@ , Data.SBV.Tuple , Data.SBV.RegExp , Data.SBV.Tools.BMC - , Data.SBV.Tools.BoundedList , Data.SBV.Tools.BVOptimize , Data.SBV.Tools.Induction - , Data.SBV.Tools.BoundedFix , Data.SBV.Tools.CodeGen , Data.SBV.Tools.GenTest , Data.SBV.Tools.KnuckleDragger @@ -154,13 +153,12 @@ , Documentation.SBV.Examples.Lists.Fibonacci , Documentation.SBV.Examples.Lists.BoundedMutex , Documentation.SBV.Examples.Lists.CountOutAndTransfer - , Documentation.SBV.Examples.KnuckleDragger.AppendRev , Documentation.SBV.Examples.KnuckleDragger.Basics , Documentation.SBV.Examples.KnuckleDragger.CaseSplit , Documentation.SBV.Examples.KnuckleDragger.Kleene - , Documentation.SBV.Examples.KnuckleDragger.Induction - , Documentation.SBV.Examples.KnuckleDragger.ListLen - , Documentation.SBV.Examples.KnuckleDragger.RevLen + , Documentation.SBV.Examples.KnuckleDragger.Lists + , Documentation.SBV.Examples.KnuckleDragger.Numeric + , Documentation.SBV.Examples.KnuckleDragger.ShefferStroke , Documentation.SBV.Examples.KnuckleDragger.Sqrt2IsIrrational , Documentation.SBV.Examples.KnuckleDragger.Tao , Documentation.SBV.Examples.Misc.Definitions @@ -274,8 +272,9 @@ , Data.SBV.Provers.OpenSMT , Data.SBV.Provers.Yices , Data.SBV.Provers.Z3 - , Data.SBV.Tools.KDKernel - , Data.SBV.Tools.KDUtils + , Data.SBV.Tools.KD.Kernel + , Data.SBV.Tools.KD.KnuckleDragger + , Data.SBV.Tools.KD.Utils , Data.SBV.Utils.CrackNum , Data.SBV.Utils.ExtractIO , Data.SBV.Utils.Numeric @@ -316,7 +315,6 @@ , TestSuite.Basics.Assert , TestSuite.Basics.BarrelRotate , TestSuite.Basics.BasicTests - , TestSuite.Basics.BoundedList , TestSuite.Basics.DynSign , TestSuite.Basics.EqSym , TestSuite.Basics.Exceptions