diff --git a/CHANGES.md b/CHANGES.md --- a/CHANGES.md +++ b/CHANGES.md @@ -1,6 +1,48 @@ * Hackage: * GitHub: +### Version 14.9, 2026-10-28 + + * Add `Documentation/SBV/Examples/TP/Huffman.hs`, proving optimality of Huffman coding. + + * Add `Documentation/SBV/Examples/Puzzles/Rubik.hs`, with examples of bounded shortest + and two-phase solutions for Rubik's Cube. + + * Fix compilation with GHC 9.14.2, whose deepseq deprecates `NFData` instances + for function types. Thanks to the Stackage curators for the report. + + * Model validation (`validateModel`) now handles many more programs: models + with uninterpreted constants and functions (also in `allSat`), comparisons + of uninterpreted-sort values, floating-point operations with any rounding + mode, `fpFMA`, and overflow checks. When a model can't be validated, the + error now says why; for instance, when the model relies on a value SMTLib + leaves unspecified, such as an ADT field accessed with the wrong constructor + or the head of an empty list. + + * Fixed a crash when validating models of programs that use recursive + `smtFunction` definitions. + + * Floating-point operations on `SFloat` and `SDouble` now evaluate concretely + with all rounding modes, and `fpFMA` evaluates concretely for all + floating-point types. Overflow checks in `Data.SBV.Tools.Overflow` and set + operations mixing complemented and regular sets also evaluate concretely. + + * Fixed `fpFromDouble`, which tagged its result with one extra bit of + precision, so later arithmetic on it could round incorrectly. + + * Fixed concrete equality of arrays, which could report equal arrays as + different when one of them had an explicit entry holding the default value, + as in `a .== writeArray a k (readArray a k)`, including when such arrays are + nested inside other arrays. Concrete array equality is also decided in more + cases when the arrays have different defaults: arrays indexed by `Integer`, + `String`, list, or rational values are then unequal, and for bit-vector, + `Bool`, or enumeration indexes, the result is decided by checking whether + the explicit entries cover every index. + + * [BACKWARDS COMPATIBILITY] `SMTModel` has a new field, `modelUIBindings`. + Code that constructs or pattern-matches `SMTModel` positionally needs to + account for it. + ### Version 14.8, 2026-09-25 * The main change in this release is a new C backend, with much broader @@ -1216,7 +1258,7 @@ The new algorithm has been measured to be at least an order of magnitude faster or more in common cases as it splits the search space into disjoint models, reducing the burden of accumulated lemmas over multiple calls. (See - http://theory.stanford.edu/%7Enikolaj/programmingz3.html#sec-blocking-evaluations + https://z3prover.github.io/papers/programmingz3.html#sec-blocking-evaluations for details.) ### Version 8.12, 2021-03-09 diff --git a/Data/SBV.hs b/Data/SBV.hs --- a/Data/SBV.hs +++ b/Data/SBV.hs @@ -913,25 +913,25 @@ allSatPartition "p2" $ y .>= 0 :} Solution #1: + x = 0 :: Integer + y = -1 :: Integer + p1 = True :: Bool + p2 = False :: Bool +Solution #2: x = -1 :: Integer y = 0 :: Integer p1 = False :: Bool p2 = True :: Bool -Solution #2: - x = 0 :: Integer - y = 0 :: Integer - p1 = True :: Bool - p2 = True :: Bool Solution #3: - x = 0 :: Integer - y = -1 :: Integer - p1 = True :: Bool - p2 = False :: Bool -Solution #4: x = -1 :: Integer y = -1 :: Integer p1 = False :: Bool p2 = False :: Bool +Solution #4: + x = 0 :: Integer + y = 0 :: Integer + p1 = True :: Bool + p2 = True :: Bool Found 4 different solutions. Without the call to 'allSatPartition' the above example, 'allSat' would return all possible combinations of @x@ and @y@ subject to the constraints. (Since we have none here, 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 @@ -696,6 +696,7 @@ , modelBindings = Nothing , modelAssocs = assocs , modelUIFuns = [] + , modelUIBindings = Nothing } pure $ Satisfiable queryConfig m 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 @@ -203,7 +203,8 @@ debug cfg ["[MEASURE] Verifying termination measures for: " <> T.pack (intercalate ", " nms)] mapM_ (\(nm, isProductive, check) -> do debug cfg ["[MEASURE] Checking: " <> T.pack nm] - check cfg + -- Counterexamples to rejected measure candidates are internal; no need to validate them + check cfg{validateModel = False} let tag = if isProductive then "productive" else "terminating" debug cfg ["[MEASURE] Passed (" <> tag <> "): " <> T.pack nm] ) checks @@ -1418,7 +1419,7 @@ -- -- So, if these two things are present, we go the "slow" route, by repeatedly rejecting the -- previous model and asking for a new one. If they don't exist (which is the common case anyhow) - -- we use an idea due to z3 folks + -- we use an idea due to z3 folks -- which splits the search space into disjoint models and can produce results much more quickly. let isSimple = null allUiFuns && null usorts && not (hasQuants progInfo) @@ -1524,12 +1525,15 @@ obsvs <- getObservables + uiBindings <- getUIBindings Nothing + let lassocs = F.toList assocs model = SMTModel { modelObjectives = [] , modelBindings = F.toList <$> bindings , modelAssocs = (first T.unpack <$> sortOn fst obsvs) <> [(T.unpack n, cv) | (_, (n, (_, cv))) <- lassocs] , modelUIFuns = [] + , modelUIBindings = uiBindings } currentResult = Satisfiable cfg model @@ -1628,12 +1632,15 @@ then Just <$> mapM grab allInputs else pure Nothing + uiBindings <- getUIBindings Nothing + let model = SMTModel { modelObjectives = [] , modelBindings = F.toList <$> bindings , modelAssocs = uiRegVals <> (first T.unpack <$> sortOn fst obsvs) <> [(T.unpack n, cv) | (_, (n, (_, cv))) <- F.toList assocs] , modelUIFuns = uiFunVals + , modelUIBindings = uiBindings } m = Satisfiable cfg model @@ -2182,19 +2189,37 @@ uiVals <- mapM (\ui@(nm, (_, _, _)) -> (nm,) <$> getUICVal mbi ui) uiRegs + uiBindings <- getUIBindings mbi + pure $ unBarModel $ SMTModel { modelObjectives = [] , modelBindings = F.toList <$> bindings , modelAssocs = uiVals ++ F.toList (first T.unpack <$> assocs) , modelUIFuns = uiFunVals + , modelUIBindings = uiBindings } +-- | Collect the values of all uninterpreted constants and functions, so they can be used during model validation. +-- Note that we collect all of them here, ignoring 'allSatTrackUFs' and 'isNonModelVar'; as validation needs them all. +-- Constants are represented as functions with no arguments: The table is empty, and the value is the default. +getUIBindings :: (MonadIO m, MonadQuery m) => Maybe Int -> m (Maybe [(String, Either String ([([CV], CV)], CV))]) +getUIBindings mbi = do + cfg <- getConfig + if not (validationRequested cfg) + then pure Nothing + else do uis <- getUIs + let get ui@(nm, (_, _, SBVType as)) + | length as == 1 = (\cv -> (nm, Right ([], cv))) <$> getUICVal mbi ui + | True = (nm,) <$> getUIFunCVAssoc mbi ui + Just <$> mapM get uis + -- | Remove the bars from model names; these are (mostly!) automatically inserted unBarModel :: SMTModel -> SMTModel -unBarModel SMTModel {modelObjectives, modelBindings, modelAssocs, modelUIFuns} +unBarModel SMTModel {modelObjectives, modelBindings, modelAssocs, modelUIFuns, modelUIBindings} = SMTModel { modelObjectives = ubf <$> modelObjectives , modelBindings = (ubn <$>) <$> modelBindings , modelAssocs = ubf <$> modelAssocs , modelUIFuns = ubf <$> modelUIFuns + , modelUIBindings = (ubf <$>) <$> modelUIBindings } where ubf (n, a) = (unBar n, a) ubn (NamedSymVar sv nm, a) = (NamedSymVar sv (unBarT nm), a) diff --git a/Data/SBV/Core/Floating.hs b/Data/SBV/Core/Floating.hs --- a/Data/SBV/Core/Floating.hs +++ b/Data/SBV/Core/Floating.hs @@ -57,8 +57,8 @@ -- | A class of floating-point (IEEE754) operations, some of -- which behave differently based on rounding modes. Note that unless --- the rounding mode is concretely RoundNearestTiesToEven, we will --- not concretely evaluate these, but rather pass down to the SMT solver. +-- the rounding mode is concrete, we will not concretely evaluate these, +-- but rather pass down to the SMT solver. class (SymVal a, RealFloat a) => IEEEFloating a where -- | Compute the floating point absolute value. fpAbs :: SBV a -> SBV a @@ -134,17 +134,18 @@ fpIsPoint :: SBV a -> SBool -- Default definitions. Minimal complete definition: None! All should be taken care by defaults - -- Note that we never evaluate FMA concretely, as there's no fma operator in Haskell + -- Note that operations taking a rounding mode go through the SVal level operations, which + -- can concretely evaluate with all rounding modes, including FMA. fpAbs = lift1 FP_Abs (Just abs) Nothing fpNeg = lift1 FP_Neg (Just negate) Nothing - fpAdd = lift2 FP_Add (Just (+)) . Just - fpSub = lift2 FP_Sub (Just (-)) . Just - fpMul = lift2 FP_Mul (Just (*)) . Just - fpDiv = lift2 FP_Div (Just (/)) . Just - fpFMA = lift3 FP_FMA Nothing . Just - fpSqrt = lift1 FP_Sqrt (Just sqrt) . Just + fpAdd = liftSVRM2 svFPAdd + fpSub = liftSVRM2 svFPSub + fpMul = liftSVRM2 svFPMul + fpDiv = liftSVRM2 svFPDiv + fpFMA rm a b c = SBV $ svFPFMA (unSBV rm) (unSBV a) (unSBV b) (unSBV c) + fpSqrt = liftSVRM1 svFPSqrt fpRem = lift2 FP_Rem (Just fpRemH) Nothing - fpRoundToIntegral = lift1 FP_RoundToIntegral (Just fpRoundToIntegralH) . Just + fpRoundToIntegral = liftSVRM1 svFPRoundToIntegral fpMin = liftMM FP_Min (Just fpMinH) Nothing fpMax = liftMM FP_Max (Just fpMaxH) Nothing fpIsEqualObject = lift2B FP_ObjEqual (Just fpIsEqualObjectH) Nothing @@ -373,6 +374,14 @@ -- From and To are the same when the source is an arbitrary float! fromSFloatingPoint = toSFloatingPoint + +-- | Lift an SVal level unary floating-point operation taking a rounding mode +liftSVRM1 :: (SVal -> SVal -> SVal) -> SRoundingMode -> SBV a -> SBV a +liftSVRM1 f rm a = SBV $ f (unSBV rm) (unSBV a) + +-- | Lift an SVal level binary floating-point operation taking a rounding mode +liftSVRM2 :: (SVal -> SVal -> SVal -> SVal) -> SRoundingMode -> SBV a -> SBV a -> SBV a +liftSVRM2 f rm a b = SBV $ f (unSBV rm) (unSBV a) (unSBV b) -- | Is this RM safe to concretely calculate with? OK if there's no RM for this op, or if it is RNE safeRM :: Maybe SRoundingMode -> Bool 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 @@ -3720,7 +3720,7 @@ | Just mustHold <- unliteral cond = if mustHold then x - else error $ show $ SafeResult (locInfo . getCallStack <$> cs, msg, Satisfiable defaultSMTCfg (SMTModel [] Nothing [] [])) + else error $ show $ SafeResult (locInfo . getCallStack <$> cs, msg, Satisfiable defaultSMTCfg (SMTModel [] Nothing [] [] Nothing)) | True = SBV $ SVal k $ Right $ cache r where k = kindOf x @@ -4686,7 +4686,7 @@ Just b -> pure (cond, b, tvals ++ mapMaybe getObservable ovals) uis -> cantQuickCheck $ "Uninterpreted constants remain: " ++ unwords uis - complain qcInfo = showModel defaultSMTCfg (SMTModel [] Nothing qcInfo []) + complain qcInfo = showModel defaultSMTCfg (SMTModel [] Nothing qcInfo [] Nothing) -- Complain if what we got isn't something we can quick-check cantQuickCheck :: String -> a 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 @@ -65,7 +65,7 @@ import Data.Bits (Bits(..)) import Data.List (genericIndex, genericLength, genericTake, foldr, length, foldl', elem, nub, sort, null, elemIndex) -import Data.Maybe (isNothing) +import Data.Maybe (isNothing, fromMaybe) import Data.SBV.Core.AlgReals import Data.SBV.Core.Kind @@ -590,6 +590,12 @@ -- ADTs. Only equal/inequal on full ADTs. Compares on enumerations. (CADT (s, fks), CADT (s', fks')) -> case k of + -- Uninterpreted sorts. Distinct names in the model denote distinct elements. Only allow equality/inequality. + KADT _ [] [] | op `elem` [Equal True, Equal False, NotEqual] + -> Just $ if s == s' then EQ else GT -- Pick GT if different; so equality test will fail, inequality will pass + | True + -> error $ "cCompare: Received unexpected uninterpreted sort comparison: " ++ show (op, k) + -- Enumerations. We do a straight comparison on the constructor index KADT _ _ cstrs | all (null . snd) cstrs -> let cnms = map fst cstrs @@ -650,34 +656,72 @@ -- a means of checking this sort of equality svSetEqual :: Kind -> RCSet CVal -> RCSet CVal -> Maybe Bool svSetEqual ek sa sb - | eqCheckIsObjectEq ek, RegularSet a <- sa, RegularSet b <- sb = Just $ a == b - | eqCheckIsObjectEq ek, ComplementSet a <- sa, ComplementSet b <- sb = Just $ a == b - | True = Nothing + | structural ek, RegularSet a <- sa, RegularSet b <- sb = Just $ a == b + | structural ek, ComplementSet a <- sa, ComplementSet b <- sb = Just $ a == b + | True = Nothing -- | Array equality. See above comments. svArrEqual :: Kind -> Kind -> ArrayModel CVal CVal -> ArrayModel CVal CVal -> Maybe Bool svArrEqual k1 k2 (ArrayModel asc1 def1) (ArrayModel asc2 def2) - | not (all eqCheckIsObjectEq [k1, k2]) + | not (structural k1 && eqCheckIsObjectEq k2) = Nothing | True - = let -- Use of lookup is safe here, because we already made sure equality is *not* problematic above - keysMatch = and [key `lookup` asc1 == key `lookup` asc2 | key <- nub (sort (map fst (asc1 ++ asc2)))] - defsMatch = def1 == def2 + = let -- Use of lookup is safe here, because we already made sure equality on keys is structural above + -- Note that a key missing from one table maps to that table's default. + valueAt asc def key = fromMaybe def (key `lookup` asc) - -- Check if keys cover everything. Clearly, we can't do this for all kinds; but only finite ones - -- For the time being, we're restricting ourselves to bool only. Might want to extend this later. - complete = case k1 of - KBool -> let bools = map cvVal [falseCV, trueCV] - covered asc = all (`elem` map fst asc) bools - in covered asc1 && covered asc2 - _ -> False + -- Values can contain arrays themselves, so we compare them recursively, not structurally + same v1 v2 = (== EQ) <$> cCompare k2 (Equal True) v1 v2 + allSame cmps + | Just False `elem` cmps = Just False + | all (== Just True) cmps = Just True + | True = Nothing + + keys = nub (sort (map fst (asc1 ++ asc2))) + keysMatch = allSame [same (valueAt asc1 def1 key) (valueAt asc2 def2 key) | key <- keys] + defsMatch = same def1 def2 + + -- Number of elements of the index type, if it's finite and we can count it + size :: Maybe Integer + size = case k1 of + KBool -> Just 2 + KBounded _ n -> Just (2 ^ n) + KADT _ [] cstrs + | not (null cstrs) + , all (null . snd) cstrs -> Just (genericLength cstrs) + _ -> Nothing + + infinite = case k1 of + KUnbounded -> True + KRational -> True + KString -> True + KList{} -> True + _ -> False + + -- The keys are distinct elements of the index type, so we can count them to see if they cover it. + -- If they do, the defaults are never used. If they don't, some index maps to the defaults. + nKeys = genericLength keys + complete = size == Just nKeys + uncovered = infinite || maybe False (nKeys <) size + in case (keysMatch, defsMatch, complete) of - (False, _ , _) -> Just False -- keys mismatch. Nothing else matters. - (True, True, _) -> Just True -- keys match, def matches; so all is good. Complete doesn't matter. - (True, False, True) -> Just True -- keys match, but defs don't. But we keys are complete, so def mismatch is OK - _ -> Nothing -- otherwise, we don't really know. So, remain symbolic. + (Just False, _ , _ ) -> Just False -- keys mismatch. Nothing else matters. + (Just True, Just True , _ ) -> Just True -- keys match, def matches; so all is good. Complete doesn't matter. + (Just True, _ , True) -> Just True -- keys match, and keys are complete, so defaults don't matter + (_, Just False, _ ) | uncovered + -> Just False -- defaults differ, and some index maps to the defaults + _ -> Nothing -- otherwise, we don't really know. So, remain symbolic. + -- | Can we use the Eq instance of CVal for object equality on values of this kind? Not if there + -- are floats (see 'eqCheckIsObjectEq'), and not if there are arrays or sets, since the same array or set + -- can have different representations. + structural :: Kind -> Bool + structural ek = eqCheckIsObjectEq ek && not (any nested (expandKinds ek)) + where nested KArray{} = True + nested KSet{} = True + nested _ = False + -- | Equality. This is SMT object equality. svEqual :: SVal -> SVal -> SVal svEqual = compareSV (Equal False) @@ -1183,15 +1227,11 @@ -- Note that this operation is defined somewhat unusually because Haskell lacks -- a native FMA operation to use for concrete evaluation of 'Float's and -- 'Double's. See https://github.com/LeventErkok/sbv/issues/777 for more --- discussion. As such, concrete FMA evaluation is only supported for t'FP' --- values. +-- discussion. As such, concrete FMA evaluation is done via t'FP' values. svFPFMA :: SVal -- ^ Rounding mode -> SVal -> SVal -> SVal -> SVal -svFPFMA (svAsRoundingMode -> Just rm) - (SVal k (Left (cvVal -> CFP a))) - (SVal _ (Left (cvVal -> CFP b))) - (SVal _ (Left (cvVal -> CFP c))) = - SVal k $ Left $ CV k $ CFP $ fpFMA rm a b c +svFPFMA (svAsRoundingMode -> Just rm) (SVal k (Left a)) (SVal _ (Left b)) (SVal _ (Left c)) = + SVal k $ Left $ viaFP k $ fpFMA rm (cvToFP a) (cvToFP b) (cvToFP c) svFPFMA rm a@(SVal k _) b c = SVal k $ Right $ cache ca where ca st = do svrm <- svToSV st rm sva <- svToSV st a @@ -1238,6 +1278,18 @@ (fromRational r) (\eb sb -> fpFromRational eb sb r) +-- | Convert a floating-point t'CV' to an t'FP' value of the same precision. This will error +-- if the t'CV' is not a floating-point value. +cvToFP :: CV -> FP +cvToFP = cvalToFP . cvVal + +-- | Convert the result of an t'FP' computation back to a t'CV' of the given floating-point 'Kind'. +-- This is used for concrete evaluation of 'Float' and 'Double' operations that Haskell does not support +-- natively, by doing the computation over t'FP' values of the same precision. Since the result is +-- exactly representable, the rounding mode used in the conversion is irrelevant. +viaFP :: Kind -> FP -> CV +viaFP k = cvCastFromFP k RoundNearestTiesToEven + -- | Convert a 'CVal' to an t'FP' value of the appropriate size. This will error -- if the 'CVal' is not a floating-point value. cvalToFP :: CVal -> FP @@ -1594,16 +1646,57 @@ -------------------------------------------------------------------------------- -- | Overflow detection. svMkOverflow1 :: OvOp -> SVal -> SVal +svMkOverflow1 o (SVal k (Left x)) | Just r <- cvOverflow o k [x] = svBool r svMkOverflow1 o x = SVal KBool (Right (cache r)) where r st = do sx <- svToSV st x newExpr st KBool $ SBVApp (OverflowOp o) [sx] svMkOverflow2 :: OvOp -> SVal -> SVal -> SVal +svMkOverflow2 o (SVal k (Left x)) (SVal _ (Left y)) | Just r <- cvOverflow o k [x, y] = svBool r svMkOverflow2 o x y = SVal KBool (Right (cache r)) where r st = do sx <- svToSV st x sy <- svToSV st y newExpr st KBool $ SBVApp (OverflowOp o) [sx, sy] +-- | Concretely determine if an overflow occurs, by computing the result over unbounded +-- integers and checking that it's within the bounds of an n-bit word. Following SMTLib, the +-- signedness is determined by the operation, not by the kind of the arguments: The arguments +-- are reinterpreted as signed or unsigned values of the same bits as needed. +cvOverflow :: OvOp -> Kind -> [CV] -> Maybe Bool +cvOverflow o k args = case (k, map cvVal args) of + (KBounded _ n, [CInteger a]) | n > 0 -> unary n (as n a) + (KBounded _ n, [CInteger a, CInteger b]) | n > 0 -> binary n (as n a) (as n b) + _ -> Nothing + where signed = case o of + PlusOv s -> s + SubOv s -> s + MulOv s -> s + DivOv -> True + NegOv -> True + + -- Interpret the bits of the value as signed/unsigned, as required by the operation + as n v + | signed, v >= 2 ^ (n-1) = v - 2 ^ n + | not signed, v < 0 = v + 2 ^ n + | True = v + + minB, maxB :: Int -> Integer + minB n = if signed then -(2 ^ (n-1)) else 0 + maxB n = if signed then 2 ^ (n-1) - 1 else 2 ^ n - 1 + + outside n v = v < minB n || v > maxB n + + unary n a = case o of + NegOv -> Just $ a == minB n + _ -> Nothing + + binary n a b = case o of + PlusOv _ -> Just $ outside n (a + b) + SubOv _ -> Just $ outside n (a - b) + MulOv _ -> Just $ outside n (a * b) + DivOv -> Just $ a == minB n && b == -1 + NegOv -> Nothing + -------------------------------------------------------------------------------- -- Utility functions @@ -1697,10 +1790,10 @@ where c st = do sva <- svToSV st a opS st k sva --- | Like 'liftFPSym1', but with an explicit rounding mode. Note that concrete --- evaluation of 'Float's or 'Double's is only supported when the +-- | Like 'liftFPSym1', but with an explicit rounding mode. Note that the native +-- Haskell operations on 'Float's or 'Double's are only used when the -- 'RoundNearestTiesToEven' rounding mode is used (see the Haddocks for --- 'floatDoubleRneCheck'). +-- 'floatDoubleRneCheck'). Otherwise, we compute via t'FP' values. liftFPSymRM1 :: String -> (State -> Kind -> SV -> SV -> IO SV) -> (Float -> Float) @@ -1708,9 +1801,10 @@ -> (RoundingMode -> FP -> FP) -> SVal -> SVal -> SVal liftFPSymRM1 o _ opCF opCD opFP rm (SVal k (Left a)) - | Just rm'@RoundNearestTiesToEven <- svAsRoundingMode rm - , floatDoubleRneCheck rm' a - = SVal k . Left $! mapCV (noRealUnary o) (noIntUnary o) opCF opCD (opFP rm') (noRatUnary o) a + | Just rm' <- svAsRoundingMode rm + = SVal k . Left $! if floatDoubleRneCheck rm' a + then mapCV (noRealUnary o) (noIntUnary o) opCF opCD (opFP rm') (noRatUnary o) a + else viaFP k (opFP rm' (cvToFP a)) liftFPSymRM1 _ opS _ _ _ rm a@(SVal k _) = SVal k $ Right $ cache c where c st = do svrm <- svToSV st rm sva <- svToSV st a @@ -1731,10 +1825,10 @@ svb <- svToSV st b opS st k sva svb --- | Like 'liftFPSym2', but with an explicit rounding mode. Note that concrete --- evaluation of 'Float's or 'Double's is only supported when the +-- | Like 'liftFPSym2', but with an explicit rounding mode. Note that the native +-- Haskell operations on 'Float's or 'Double's are only used when the -- 'RoundNearestTiesToEven' rounding mode is used (see the Haddocks for --- 'floatDoubleRneCheck'). +-- 'floatDoubleRneCheck'). Otherwise, we compute via t'FP' values. liftFPSymRM2 :: String -> (State -> Kind -> SV -> SV -> SV -> IO SV) -> (Float -> Float -> Float) @@ -1742,9 +1836,10 @@ -> (RoundingMode -> FP -> FP -> FP) -> SVal -> SVal -> SVal -> SVal liftFPSymRM2 o _ opCF opCD opFP rm (SVal k (Left a)) (SVal _ (Left b)) - | Just rm'@RoundNearestTiesToEven <- svAsRoundingMode rm - , floatDoubleRneCheck rm' a - = SVal k . Left $! mapCV2 (noReal o) (noInt o) opCF opCD (opFP rm') (noRat o) a b + | Just rm' <- svAsRoundingMode rm + = SVal k . Left $! if floatDoubleRneCheck rm' a + then mapCV2 (noReal o) (noInt o) opCF opCD (opFP rm') (noRat o) a b + else viaFP k (opFP rm' (cvToFP a) (cvToFP b)) liftFPSymRM2 _ opS _ _ _ rm a@(SVal k _) b = SVal k $ Right $ cache c where c st = do svrm <- svToSV st rm sva <- svToSV st a @@ -1859,9 +1954,9 @@ rationalSBVCheck _ _ = True -- | Predicate to check if a concrete 'Float' or 'Double' value uses the --- 'RoundNearestTiesToEven' rounding mode. This is necessary because we assume --- this rounding mode when concretely evaluating 'Float's and 'Double's, so --- concrete evaluation is not supported for other rounding modes. +-- 'RoundNearestTiesToEven' rounding mode. This is necessary because the native +-- Haskell operations on 'Float's and 'Double's assume this rounding mode, so +-- for other rounding modes we concretely evaluate via t'FP' values instead. -- -- Note that this check skips concrete t'FP' values, which support concrete -- evaluation with any rounding mode. 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 @@ -601,7 +601,7 @@ -- | Convert from a IEEE double. fpFromDouble :: Int -> Int -> Double -> FP -fpFromDouble 11 53 d = FP 11 54 $ BF.bfFromDouble d +fpFromDouble 11 53 d = FP 11 53 $ BF.bfFromDouble d fpFromDouble eb sb d = error $ "SBV.fpFromDouble: Unexpected input: " ++ show (eb, sb, d) -- | Convert to a IEEE float using the given rounding mode. 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 @@ -1212,10 +1212,10 @@ , T.unpack (body 2) ] --- | NFData instance for SMTDef +-- | NFData instance for SMTDef. The body is a function, so we can only force it to WHNF. instance NFData SMTDef where rnf (SMTDefValue fk frees params body lambdaInfo) - = rnf fk `seq` rnf frees `seq` rnf params `seq` rnf body `seq` rnf lambdaInfo + = rnf fk `seq` rnf frees `seq` rnf params `seq` body `seq` rnf lambdaInfo -- | Compare two SMTDef values for semantic equality. -- The body is @(Int -> Text)@ where @Int@ is indentation; we compare rendered output at indent 0. @@ -2235,10 +2235,13 @@ instance NFData Result where rnf (Result hasQuants kindInfo qcInfo obs cgs inps consts tbls uis axs pgm cstr asserts outs) - = rnf hasQuants `seq` rnf kindInfo `seq` rnf qcInfo `seq` rnf obs `seq` rnf cgs + = rnf hasQuants `seq` rnf kindInfo `seq` rnf qcInfo `seq` rnfObs `seq` rnf cgs `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 + where -- Observables carry a function, which we can only force to WHNF + rnfObs = rnf [(n, sv) | (n, f, sv) <- obs, f `seq` True] + instance NFData SV where rnf a = seq a () instance NFData SBVExpr where rnf a = seq a () instance NFData Quantifier where rnf a = seq a () @@ -2256,7 +2259,7 @@ rnf (ProofError _ m mr) = rnf m `seq` rnf mr instance NFData SMTModel where - rnf (SMTModel objs bndgs assocs uifuns) = rnf objs `seq` rnf bndgs `seq` rnf assocs `seq` rnf uifuns + rnf (SMTModel objs bndgs assocs uifuns uibndgs) = rnf objs `seq` rnf bndgs `seq` rnf assocs `seq` rnf uifuns `seq` rnf uibndgs instance NFData SMTScript where rnf (SMTScript b m) = rnf b `seq` rnf m @@ -2317,7 +2320,7 @@ , allSatPrintAlong :: Bool -- ^ In a 'Data.SBV.allSat' call, print models as they are found. , allSatTrackUFs :: Bool -- ^ In a 'Data.SBV.allSat' call, should we try to extract values of uninterpreted functions? , isNonModelVar :: String -> Bool -- ^ When constructing a model, ignore variables whose name satisfy this predicate. (Default: (const False), i.e., don't ignore anything) - , validateModel :: Bool -- ^ If set, SBV will attempt to validate the model it gets back from the solver. + , validateModel :: Bool -- ^ If set, SBV will attempt to validate the model it gets back from the solver. (Models obtained in custom queries are not validated.) , optimizeValidateConstraints :: Bool -- ^ Validate optimization results. NB: Does NOT make sure the model is optimal, just checks they satisfy the constraints. , transcript :: Maybe FilePath -- ^ If Just, the entire interaction will be recorded as a playable file (for debugging purposes mostly) , smtLibVersion :: SMTLibVersion -- ^ What version of SMT-lib we use for the tool @@ -2368,6 +2371,9 @@ -- Note that an uninterpreted constant (function of arity 0) will be stored -- in the 'modelAssocs' field. Left is used when the function returned is too -- difficult for SBV to figure out what it means + , modelUIBindings :: Maybe [(String, Either String ([([CV], CV)], CV))] -- ^ Values of all uninterpreted constants and functions, used for model validation. + -- Only collected if model validation is requested. Constants are stored as functions + -- with no arguments, i.e., an empty table and the value as the default. } deriving Show diff --git a/Data/SBV/List.hs b/Data/SBV/List.hs --- a/Data/SBV/List.hs +++ b/Data/SBV/List.hs @@ -252,7 +252,7 @@ -- Q.E.D. -- >>> sat $ \(l :: SList Word16) -> length l .>= 2 .&& listToListAt l 0 ./= listToListAt l (length l - 1) -- Satisfiable. Model: --- s0 = [0,32] :: [Word16] +-- s0 = [0,64] :: [Word16] listToListAt :: SymVal a => SList a -> SInteger -> SList a listToListAt s offset = subList s offset 1 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 @@ -48,21 +48,26 @@ import System.Directory (getCurrentDirectory) import Data.Time (getZonedTime, NominalDiffTime, UTCTime, getCurrentTime, diffUTCTime) -import Data.List (intercalate, isPrefixOf) +import Data.List (intercalate, isPrefixOf, stripPrefix, genericIndex, genericLength) -import Data.Maybe (mapMaybe, listToMaybe) +import Data.Maybe (mapMaybe, listToMaybe, fromMaybe) +import Text.Read (readMaybe) + +import qualified Data.Map.Strict as Map import qualified Data.Set as Set (empty) -import qualified Data.Foldable as S (toList) +import qualified Data.Foldable as S (toList, foldl') import qualified Data.Text as T +import Data.SBV.Core.AlgReals (isExactRational) import Data.SBV.Core.Data import Data.SBV.Core.Symbolic +import Data.SBV.Core.Operations import Data.SBV.SMT.SMT import Data.SBV.SMT.Utils (debug, alignPlain) import Data.SBV.Utils.ExtractIO -import Data.SBV.Utils.Lib (showText) +import Data.SBV.Utils.Lib (showText, unBar) import Data.SBV.Utils.TDiff import Data.SBV.Lambda () -- instances only @@ -429,6 +434,11 @@ , "Unable to validate the produced model." ]) (Just res) + -- Values of uninterpreted constants/functions in the model + uiEnv = case res of + Satisfiable _ m -> fromMaybe [] (modelUIBindings m) + _ -> [] + check env = do let envShown = showModelDictionary True True cfg modelBinds where modelBinds = [(T.unpack n, RegularCV v) | (NamedSymVar _ n, v) <- env] @@ -441,7 +451,17 @@ result <- snd <$> runSymbolic cfg (Concrete (Just (isSAT, env))) (reducer p >>= output) - let explain = [ "" + let -- Values that remained symbolic in the concrete run, but can be computed using + -- the model values of uninterpreted constants and functions + residual = evalResidual uiEnv result + + -- Boolean value of an SV, if we can compute it + valueOf sv + | sv == trueSV = Just True + | sv == falseSV = Just False + | True = cvToBool <$> sv `Map.lookup` residual + + explain = [ "" , "Assignment:" ++ if null env then " " else "" ] ++ [ "" | not (null env)] @@ -461,7 +481,7 @@ ] notConcrete sv = wrap ("Data.SBV: Cannot validate the model, since " ++ show sv ++ " is not concretely computable.") - ( perhaps (why sv) + ( perhaps (explainResidual uiEnv result residual sv) ) where perhaps Nothing = case resObservables result of [] -> [] @@ -476,19 +496,6 @@ , "Please report this as a feature request or possibly a bug!" ] - -- This is incomplete, but should capture the most common cases - why s = case s `lookup` S.toList (pgmAssignments (resAsgns result)) of - Nothing -> Nothing - Just (SBVApp o as) -> case o of - QuantifiedBool{} -> Just "The value depends on a quantified variable." - IEEEFP FP_FMA -> Just "Floating point FMA operation is not supported concretely." - IEEEFP _ -> Just "Not all floating point operations are supported concretely." - OverflowOp _ -> Just "Overflow-checking is not done concretely." - Uninterpreted v - | any isADT as -> Just "Models containing ADTs are currently only partially supported." - | True -> Just $ "The value depends on the uninterpreted constant " ++ T.unpack v ++ "." - _ -> listToMaybe $ mapMaybe why as - cstrs = S.toList $ resConstraints result walkConstraints [] cont = do @@ -497,9 +504,9 @@ walkConstraints ((isSoft, attrs, sv) : rest) cont | kindOf sv /= KBool = giveUp $ "Constraint tied to " ++ show sv ++ " is non-boolean." - | isSoft || sv == trueSV + | isSoft || valueOf sv == Just True = walkConstraints rest cont - | sv == falseSV + | valueOf sv == Just False = case mbName of Just nm -> badModel $ "Named constraint " ++ show nm ++ " evaluated to False." Nothing -> badModel "A constraint was violated." @@ -514,9 +521,9 @@ satLoop (sv:svs) | kindOf sv /= KBool = giveUp $ "Output tied to " ++ show sv ++ " is non-boolean." - | sv == trueSV + | valueOf sv == Just True = satLoop svs - | sv == falseSV + | valueOf sv == Just False = badModel "Final output evaluated to False." | True = notConcrete sv @@ -530,9 +537,9 @@ proveLoop (sv:svs) somethingFailed | kindOf sv /= KBool = giveUp $ "Output tied to " ++ show sv ++ " is non-boolean." - | sv == trueSV + | valueOf sv == Just True = proveLoop svs somethingFailed - | sv == falseSV + | valueOf sv == Just False = proveLoop svs True | True = notConcrete sv @@ -551,6 +558,205 @@ else "Validating " ++ show (length cstrs) ++ " constraint(s)." walkConstraints cstrs (checkOutputs (resOutputs result)) + +-- | Values of uninterpreted constants and functions in a model, as used during validation. +type UIEnv = [(String, Either String ([([CV], CV)], CV))] + +-- | Find the model value of an uninterpreted constant/function. +lookupUI :: UIEnv -> T.Text -> Maybe (Either String ([([CV], CV)], CV)) +lookupUI uis f = unBar (T.unpack f) `lookup` [(unBar n, v) | (n, v) <- uis] + +-- | After the concrete run of model validation, some values remain symbolic if they depend on +-- uninterpreted constants or functions. Evaluate them using the values of the uninterpreted +-- values in the model. We return all the values we can compute. +evalResidual :: UIEnv -> Result -> Map.Map SV CV +evalResidual uis result = S.foldl' step initial (pgmAssignments (resAsgns result)) + where initial = Map.fromList $ (trueSV, trueCV) : (falseSV, falseCV) : snd (resConsts result) + + step known (sv, SBVApp op args) = maybe known (\cv -> Map.insert sv cv known) (evalNode known (kindOf sv) op args) + + evalNode known k op args + -- For ite, we only need the value of the branch taken + | Ite <- op, [c, t, e] <- args + = do b <- cvToBool <$> c `Map.lookup` known + (if b then t else e) `Map.lookup` known + -- Short-cut and/or. Note that these are also used for bit-vectors, where we can't short-cut. + | And <- op, k == KBool, any (has False) args = Just falseCV + | Or <- op, k == KBool, any (has True) args = Just trueCV + | True = mapM (`Map.lookup` known) args >>= evalOp uis k op + where has b a = (cvToBool <$> a `Map.lookup` known) == Just b + +-- | Evaluate an operation on concrete arguments, using the model values of uninterpreted +-- constants and functions. Returns 'Nothing' if we cannot. +evalOp :: UIEnv -> Kind -> Op -> [CV] -> Maybe CV +evalOp uis k op args = case (op, args) of + (Uninterpreted f, _) -> case lookupUI uis f of + Just (Right (tbl, def)) -> lookupFirst args tbl def + _ -> Nothing + + (Label _, [a]) -> Just a + + (TupleConstructor _, _) -> Just $ CV k (CTuple (map cvVal args)) + (TupleAccess i _, [CV _ (CTuple vs)]) + | i >= 1, i <= length vs -> Just $ CV k (vs !! (i-1)) + + (ADTOp (ADTConstructor c _), _) -> Just $ CV k (CADT (T.unpack c, [(kindOf a, cvVal a) | a <- args])) + (ADTOp (ADTTester t _), [CV _ (CADT (c, _))]) -> Just $ if T.unpack t == "is-" ++ c then trueCV else falseCV + (ADTOp (ADTAccessor a _), [CV _ (CADT (c, fs))]) + | Just i <- accessorIndex c (T.unpack a), i >= 1, i <= length fs + -> Just $ CV k (snd (fs !! (i-1))) + + (SeqOp (SeqNth _), [CV _ (CList xs), CV _ (CInteger i)]) + | i >= 0, i < genericLength xs -> Just $ CV k (xs `genericIndex` i) + + (ReadArray, [CV (KArray ki _) (CArray (ArrayModel tbl def)), i]) + -> CV k <$> lookupFirst [i] [([CV ki key], v) | (key, v) <- tbl] def + (WriteArray, [CV _ (CArray (ArrayModel tbl def)), i, v]) -> Just $ CV k $ CArray $ ArrayModel ((cvVal i, cvVal v) : tbl) def + + _ -> case (op, map lit args) of + (Plus, [a, b]) -> conc $ svPlus a b + (Times, [a, b]) -> conc $ svTimes a b + (Minus, [a, b]) -> conc $ svMinus a b + (UNeg, [a]) -> conc $ svUNeg a + (Abs, [a]) -> conc $ svAbs a + (Quot, [a, b]) -> conc $ svQuot a b + (Rem, [a, b]) -> conc $ svRem a b + (Equal True, [a, b]) -> conc $ svStrongEqual a b + (Equal False, [a, b]) -> conc $ svEqual a b + (NotEqual, [a, b]) -> conc $ svNotEqual a b + (LessThan, [a, b]) -> conc $ svLessThan a b + (GreaterThan, [a, b]) -> conc $ svGreaterThan a b + (LessEq, [a, b]) -> conc $ svLessEq a b + (GreaterEq, [a, b]) -> conc $ svGreaterEq a b + (Implies, [a, b]) -> conc $ svImplies a b + (And, [a, b]) -> conc $ svAnd a b + (Or, [a, b]) -> conc $ svOr a b + (XOr, [a, b]) -> conc $ svXOr a b + (Not, [a]) -> conc $ svNot a + (Shl, [a, b]) -> conc $ svShiftLeft a b + (Shr, [a, b]) -> conc $ svShiftRight a b + (Rol i, [a]) -> conc $ svRol a i + (Ror i, [a]) -> conc $ svRor a i + (Divides n, [a]) -> conc $ svDivides n a + (Extract i j, [a]) -> conc $ svExtract i j a + (Join, [a, b]) -> conc $ svJoin a b + (ZeroExtend i, [a]) -> conc $ svZeroExtend i a + (SignExtend i, [a]) -> conc $ svSignExtend i a + (KindCast f t, [a]) + | all isIntegral [f, t] -> conc $ svFromIntegral t a + + (OverflowOp o', [a]) -> conc $ svMkOverflow1 o' a + (OverflowOp o', [a, b]) -> conc $ svMkOverflow2 o' a b + + (IEEEFP fop, largs) -> case (fop, largs) of + (FP_Abs, [a]) -> conc $ svFPAbs a + (FP_Neg, [a]) -> conc $ svFPNeg a + (FP_Add, [rm, a, b]) -> conc $ svFPAdd rm a b + (FP_Sub, [rm, a, b]) -> conc $ svFPSub rm a b + (FP_Mul, [rm, a, b]) -> conc $ svFPMul rm a b + (FP_Div, [rm, a, b]) -> conc $ svFPDiv rm a b + (FP_FMA, [rm, a, b, c]) -> conc $ svFPFMA rm a b c + (FP_Sqrt, [rm, a]) -> conc $ svFPSqrt rm a + (FP_Rem, [a, b]) -> conc $ svFPRem a b + (FP_RoundToIntegral, [rm, a]) -> conc $ svFPRoundToIntegral rm a + (FP_Min, [a, b]) -> conc $ svFPMin a b + (FP_Max, [a, b]) -> conc $ svFPMax a b + (FP_ObjEqual, [a, b]) -> conc $ svStrongEqual a b + (FP_IsNormal, [a]) -> conc $ svFPIsNormal a + (FP_IsSubnormal, [a]) -> conc $ svFPIsSubnormal a + (FP_IsZero, [a]) -> conc $ svFPIsZero a + (FP_IsInfinite, [a]) -> conc $ svFPIsInfinite a + (FP_IsNaN, [a]) -> conc $ svFPIsNaN a + (FP_IsNegative, [a]) -> conc $ svFPIsNegative a + (FP_IsPositive, [a]) -> conc $ svFPIsPositive a + _ -> Nothing + _ -> Nothing + where lit a = SVal (kindOf a) (Left a) + + conc (SVal _ (Left c)) = Just c + conc _ = Nothing + + isIntegral x = isBounded x || isUnbounded x + +-- | Look up a key in a table, where earlier entries take precedence, returning the default if there's no match. +-- Keys are compared using object equality, which can't be done structurally: The same value can have different +-- representations, as is the case for arrays. If we can't decide whether an entry matches before we find a +-- match, we return 'Nothing'. +lookupFirst :: [CV] -> [([CV], a)] -> a -> Maybe a +lookupFirst key tbl def = go tbl + where go [] = Just def + go ((k, v) : rest) = case zipWith same key k of + eqs | Just False `elem` eqs -> go rest + | all (== Just True) eqs -> Just v + | True -> Nothing + + same a b = case svStrongEqual (SVal (kindOf a) (Left a)) (SVal (kindOf b) (Left b)) of + SVal _ (Left r) -> Just (cvToBool r) + _ -> Nothing + +-- | Given a constructor name and an accessor name, find which field the accessor +-- refers to, if the accessor belongs to this constructor. Accessors are named @get_@. +accessorIndex :: String -> String -> Maybe Int +accessorIndex c a = stripPrefix ("get" ++ c ++ "_") a >>= readMaybe + +-- | Explain why an SV couldn't be computed during validation, by finding the operation responsible. +-- This is incomplete, but should capture the most common cases. +explainResidual :: UIEnv -> Result -> Map.Map SV CV -> SV -> Maybe String +explainResidual uis result known = go + where defs = Map.fromList $ S.toList $ pgmAssignments (resAsgns result) + defined = [unBar d | (d, _) <- resDefinitions result] + + go sv = case sv `Map.lookup` defs of + Nothing -> Nothing + Just (SBVApp o as) + -- Follow the branch taken in an ite + | Ite <- o, [c, t, e] <- as, Just b <- cvToBool <$> c `Map.lookup` known + -> go (if b then t else e) + -- If an argument is not known, the problem is further down + | unknowns@(_:_) <- [a | a <- as, a `Map.notMember` known] + -> case mapMaybe go unknowns of + r : _ -> Just r + [] -> Just $ describe o Nothing + | True + -> Just $ describe o (mapM (`Map.lookup` known) as) + + isIrrational (CV _ (CAlgReal r)) = not (isExactRational r) + isIrrational _ = False + + unspecified = "This value is not specified by SMTLib, and SBV cannot determine what the solver picked for it." + + describe o mbArgs = case (o, mbArgs) of + (QuantifiedBool{}, _) -> "The value depends on a quantified variable." + (IEEEFP _, _) -> "Not all floating point operations are supported concretely." + (SpecialRelOp{}, _) -> "Special relations are not supported concretely." + (ArrayInit (Right _), _) -> "Arrays created via lambdaArray are not supported concretely." + + (_, Just cvs) | any isIrrational cvs + -> "The value depends on an irrational algebraic real, which SBV cannot compute with concretely." + + (ADTOp (ADTAccessor a _), Just [CV _ (CADT (c, _))]) + -> unwords [ "The field accessor", T.unpack a, "is applied to a value built with the constructor", c ++ "." + , unspecified + ] + + (SeqOp (SeqNth _), Just [CV _ (CList xs), CV _ (CInteger i)]) + -> unwords [ "Element", show i, "of a list of length", show (length xs), "is accessed." + , unspecified + ] + + (Uninterpreted f, _) + | unBar (T.unpack f) `elem` defined + -> "The function " ++ unBar (T.unpack f) ++ " is applied to arguments that depend on uninterpreted values. SBV cannot evaluate it." + | True + -> case (lookupUI uis f, mbArgs) of + (Nothing, _) -> "The model has no value for the uninterpreted name " ++ unBar (T.unpack f) ++ "." + (Just Left{}, _) -> "The model value for the uninterpreted function " ++ unBar (T.unpack f) ++ " is too complicated for SBV to evaluate." + (Just Right{}, Just _) -> "SBV cannot decide which entry in the model value for the uninterpreted function " ++ unBar (T.unpack f) ++ " applies to its arguments." + (Just Right{}, _) -> "The uninterpreted function " ++ unBar (T.unpack f) ++ " is applied to arguments that are not concretely computable." + + (ReadArray, Just _) -> "SBV cannot decide which entry of the array applies to the index it is read at." + + _ -> "SBV cannot concretely evaluate the operation: " ++ show o -- | Given a satisfiability problem, extract the function definitions in it defs2smt :: SatisfiableM m a => a -> m String 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 @@ -527,20 +527,20 @@ -- | Show an SMTResult; generic version showSMTResult :: String -> String -> String -> String -> (Maybe String -> String) -> String -> SMTResult -> String showSMTResult unsatMsg unkMsg satMsg satMsgModel dSatMsgModel satExtMsg result = case result of - Unsatisfiable _ uc -> unsatMsg ++ showUnsatCore uc - Satisfiable _ (SMTModel _ _ [] []) -> satMsg - Satisfiable _ m -> satMsgModel ++ showModel cfg m - DeltaSat _ p m -> dSatMsgModel p ++ showModel cfg m - SatExtField _ (SMTModel b _ _ _) -> satExtMsg ++ showModelDictionary True False cfg b - Unknown _ r -> unkMsg ++ ".\n" ++ T.unpack (" Reason: " `alignPlain` showText r) - ProofError _ [] Nothing -> "*** An error occurred. No additional information available. Try running in verbose mode." - ProofError _ ls Nothing -> "*** An error occurred.\n" ++ intercalate "\n" (map ("*** " ++) ls) - ProofError _ ls (Just r) -> intercalate "\n" $ [ "*** " ++ l | l <- ls] - ++ [ "***" - , "*** Alleged model:" - , "***" - ] - ++ ["*** " ++ l | l <- lines (showSMTResult unsatMsg unkMsg satMsg satMsgModel dSatMsgModel satExtMsg r)] + Unsatisfiable _ uc -> unsatMsg ++ showUnsatCore uc + Satisfiable _ (SMTModel _ _ [] [] _) -> satMsg + Satisfiable _ m -> satMsgModel ++ showModel cfg m + DeltaSat _ p m -> dSatMsgModel p ++ showModel cfg m + SatExtField _ (SMTModel b _ _ _ _) -> satExtMsg ++ showModelDictionary True False cfg b + Unknown _ r -> unkMsg ++ ".\n" ++ T.unpack (" Reason: " `alignPlain` showText r) + ProofError _ [] Nothing -> "*** An error occurred. No additional information available. Try running in verbose mode." + ProofError _ ls Nothing -> "*** An error occurred.\n" ++ intercalate "\n" (map ("*** " ++) ls) + ProofError _ ls (Just r) -> intercalate "\n" $ [ "*** " ++ l | l <- ls] + ++ [ "***" + , "*** Alleged model:" + , "***" + ] + ++ ["*** " ++ l | l <- lines (showSMTResult unsatMsg unkMsg satMsg satMsgModel dSatMsgModel satExtMsg r)] where cfg = resultConfig result showUnsatCore Nothing = "" diff --git a/Data/SBV/Set.hs b/Data/SBV/Set.hs --- a/Data/SBV/Set.hs +++ b/Data/SBV/Set.hs @@ -147,8 +147,8 @@ -- -- >>> prove $ \x (s :: SSet Integer) -> x `delete` (x `insert` s) .== s -- Falsifiable. Counter-example: --- s0 = 2 :: Integer --- s1 = U :: {Integer} +-- s0 = 2 :: Integer +-- s1 = {2} :: {Integer} -- -- But the above is true if the element isn't in the set to start with: -- @@ -169,6 +169,10 @@ | eqCheckIsObjectEq ka, Just e <- unliteral se, Just (ComplementSet cs) <- unliteral ss, e `Set.member` cs = literal $ ComplementSet $ e `Set.delete` cs + -- Case 3: Constant complement set, with element not in the complement. It's already there: + | eqCheckIsObjectEq ka, Just _ <- unliteral se, Just ComplementSet{} <- unliteral ss + = ss + -- Otherwise, go symbolic | True = SBV $ SVal k $ Right $ cache r @@ -190,8 +194,8 @@ -- -- >>> prove $ \x (s :: SSet Integer) -> x `insert` (x `delete` s) .== s -- Falsifiable. Counter-example: --- s0 = 2 :: Integer --- s1 = U - {2} :: {Integer} +-- s0 = 2 :: Integer +-- s1 = {} :: {Integer} -- -- But the above is true if the element is in the set to start with: -- @@ -212,6 +216,10 @@ | eqCheckIsObjectEq ka, Just e <- unliteral se, Just (ComplementSet cs) <- unliteral ss, e `Set.notMember` cs = literal $ ComplementSet $ e `Set.insert` cs + -- Case 3: Constant complement set, with element in the complement. It's already missing: + | eqCheckIsObjectEq ka, Just _ <- unliteral se, Just ComplementSet{} <- unliteral ss + = ss + -- Otherwise, go symbolic | True = SBV $ SVal k $ Right $ cache r @@ -330,6 +338,11 @@ | eqCheckIsObjectEq ka, Just (ComplementSet a) <- unliteral sa, Just (ComplementSet b) <- unliteral sb = literal $ b `Set.isSubsetOf` a + -- Case 3: Constant regular set and a complement set, check they're disjoint. (Note that we don't + -- handle the reverse case, as that depends on whether the element type is finite.) + | eqCheckIsObjectEq ka, Just (RegularSet a) <- unliteral sa, Just (ComplementSet b) <- unliteral sb + = literal $ a `Set.disjoint` b + -- Otherwise, go symbolic | True = SBV $ SVal KBool $ Right $ cache r @@ -411,6 +424,12 @@ | eqCheckIsObjectEq ka, Just (ComplementSet a) <- unliteral sa, Just (ComplementSet b) <- unliteral sb = literal $ ComplementSet $ a `Set.intersection` b + -- Case 3: Constant regular and complement sets, complement the difference: + | eqCheckIsObjectEq ka, Just (RegularSet a) <- unliteral sa, Just (ComplementSet b) <- unliteral sb + = literal $ ComplementSet $ b `Set.difference` a + | eqCheckIsObjectEq ka, Just (ComplementSet a) <- unliteral sa, Just (RegularSet b) <- unliteral sb + = literal $ ComplementSet $ a `Set.difference` b + -- Otherwise, go symbolic | True = SBV $ SVal k $ Right $ cache r @@ -454,6 +473,12 @@ | eqCheckIsObjectEq ka, Just (ComplementSet a) <- unliteral sa, Just (ComplementSet b) <- unliteral sb = literal $ ComplementSet $ a `Set.union` b + -- Case 3: Constant regular and complement sets, remove the complement from the regular one: + | eqCheckIsObjectEq ka, Just (RegularSet a) <- unliteral sa, Just (ComplementSet b) <- unliteral sb + = literal $ RegularSet $ a `Set.difference` b + | eqCheckIsObjectEq ka, Just (ComplementSet a) <- unliteral sa, Just (RegularSet b) <- unliteral sb + = literal $ RegularSet $ b `Set.difference` a + -- Otherwise, go symbolic | True = SBV $ SVal k $ Right $ cache r @@ -485,10 +510,18 @@ -- Q.E.D. difference :: forall a. (Ord a, SymVal a) => SSet a -> SSet a -> SSet a difference sa sb - -- Only constant fold the regular case, others are left symbolic + -- Case 1: Constant regular sets, just compute | eqCheckIsObjectEq ka, Just (RegularSet a) <- unliteral sa, Just (RegularSet b) <- unliteral sb = literal $ RegularSet $ a `Set.difference` b + -- Other constant cases, using: a `difference` b = a `intersection` complement b + | eqCheckIsObjectEq ka, Just (RegularSet a) <- unliteral sa, Just (ComplementSet b) <- unliteral sb + = literal $ RegularSet $ a `Set.intersection` b + | eqCheckIsObjectEq ka, Just (ComplementSet a) <- unliteral sa, Just (RegularSet b) <- unliteral sb + = literal $ ComplementSet $ a `Set.union` b + | eqCheckIsObjectEq ka, Just (ComplementSet a) <- unliteral sa, Just (ComplementSet b) <- unliteral sb + = literal $ RegularSet $ b `Set.difference` a + -- Otherwise, go symbolic | True = SBV $ SVal k $ Right $ cache r @@ -515,7 +548,7 @@ False >>> sat $ \(x::SSet (Maybe Integer)) y z -> distinct [x, y, z] Satisfiable. Model: - s0 = {Just 2} :: {Maybe Integer} + s0 = {Just 3} :: {Maybe Integer} s1 = {} :: {Maybe Integer} s2 = U :: {Maybe Integer} diff --git a/Data/SBV/TP/Kernel.hs b/Data/SBV/TP/Kernel.hs --- a/Data/SBV/TP/Kernel.hs +++ b/Data/SBV/TP/Kernel.hs @@ -285,7 +285,8 @@ modifyIORef' (measuresEncountered tpSt) (Set.union allNames) let verify (n, isProductive, c) = do msg $ "[MEASURE] checkNewMeasures: verifying " ++ n - () <- c cfg + -- Counterexamples to rejected measure candidates are internal; no need to validate them + () <- c cfg{validateModel = False} msg $ "[MEASURE] checkNewMeasures: " ++ n ++ " verified" if isProductive then modifyIORef' (productiveVerified tpSt) (Set.insert n) diff --git a/Documentation/SBV/Examples/ADT/Expr.hs b/Documentation/SBV/Examples/ADT/Expr.hs --- a/Documentation/SBV/Examples/ADT/Expr.hs +++ b/Documentation/SBV/Examples/ADT/Expr.hs @@ -110,9 +110,9 @@ -- -- >>> evalSat -- Satisfiable. Model: --- e = Let "a" (Val 1313) (Add (Val (-1312)) (Var "a")) :: Expr --- a = 9 :: Integer --- b = 10 :: Integer +-- e = Let "a" (Val 5) (Mul (Val (-1)) (Add (Val 0) (Let "a" (Val 6) (Val (-1))))) :: Expr +-- a = 9 :: Integer +-- b = 10 :: Integer evalSat :: IO SatResult evalSat = sat $ do e :: SExpr <- free "e" constrain $ isValid e @@ -129,7 +129,7 @@ -- -- >>> genE -- Satisfiable. Model: --- e1 = Let "t" (Val 5) (Val 3) :: Expr +-- e1 = Let "p" (Val 4) (Val 3) :: Expr -- e2 = Val (-2) :: Expr genE :: IO SatResult genE = sat $ do e1 :: SExpr <- free "e1" @@ -146,7 +146,7 @@ -- | Query mode example. -- -- >>> queryE --- e1: (let t = 5 in 3) +-- e1: (let p = 4 in 3) -- e2: -2 queryE :: IO () queryE = runSMT $ do diff --git a/Documentation/SBV/Examples/ADT/Param.hs b/Documentation/SBV/Examples/ADT/Param.hs --- a/Documentation/SBV/Examples/ADT/Param.hs +++ b/Documentation/SBV/Examples/ADT/Param.hs @@ -119,9 +119,9 @@ -- -- >>> evalSat -- Satisfiable. Model: --- e = Let "a" (Val 1313) (Add (Val (-1312)) (Var "a")) :: Expr String Integer --- a = 9 :: Integer --- b = 10 :: Integer +-- e = Let "a" (Val 5) (Mul (Val (-1)) (Add (Val 0) (Let "a" (Val 6) (Val (-1))))) :: Expr String Integer +-- a = 9 :: Integer +-- b = 10 :: Integer evalSat :: IO SatResult evalSat = sat $ do e :: SExpr String Integer <- free "e" constrain $ isValid isId e @@ -138,7 +138,7 @@ -- -- >>> genE -- Satisfiable. Model: --- e1 = Let "s" (Val 5) (Val 3) :: Expr String Integer +-- e1 = Let "k" (Val 5) (Val 3) :: Expr String Integer -- e2 = Val (-2) :: Expr String Integer genE :: IO SatResult genE = sat $ do e1 :: SExpr String Integer <- free "e1" @@ -155,9 +155,9 @@ -- | Query mode example. -- -- >>> queryE --- e1: (let a = (-1 * -3) in (a * 1)) +-- e1: (let p = (-3 * -1) in (1 * p)) -- e2: -2 --- e3: (let h = 77 % 78 in h) +-- e3: (let a = 9 % 8 in a) queryE :: IO () queryE = runSMT $ do e1 :: SExpr String Integer <- free "e1" diff --git a/Documentation/SBV/Examples/BitPrecise/BitTricks.hs b/Documentation/SBV/Examples/BitPrecise/BitTricks.hs --- a/Documentation/SBV/Examples/BitPrecise/BitTricks.hs +++ b/Documentation/SBV/Examples/BitPrecise/BitTricks.hs @@ -6,8 +6,8 @@ -- Maintainer: erkokl@gmail.com -- Stability : experimental -- --- Checks the correctness of a few tricks from the large collection found in: --- +-- Checks the correctness of a few tricks from Sean Eron Anderson's Bit Twiddling Hacks, mirrored at: +-- ----------------------------------------------------------------------------- {-# LANGUAGE FlexibleContexts #-} @@ -18,31 +18,31 @@ import Data.SBV --- | Formalizes +-- | Formalizes fastMinCorrect :: SInt32 -> SInt32 -> SBool fastMinCorrect x y = m .== fm where m = ite (x .< y) x y fm = y `xor` ((x `xor` y) .&. (-(oneIf (x .< y)))); --- | Formalizes +-- | Formalizes fastMaxCorrect :: SInt32 -> SInt32 -> SBool fastMaxCorrect x y = m .== fm where m = ite (x .< y) y x fm = x `xor` ((x `xor` y) .&. (-(oneIf (x .< y)))); --- | Formalizes +-- | Formalizes oppositeSignsCorrect :: SInt32 -> SInt32 -> SBool oppositeSignsCorrect x y = r .== os where r = (x .< 0 .&& y .>= 0) .|| (x .>= 0 .&& y .< 0) os = (x `xor` y) .< 0 --- | Formalizes +-- | Formalizes conditionalSetClearCorrect :: SBool -> SWord32 -> SWord32 -> SBool conditionalSetClearCorrect f m w = r .== r' where r = ite f (w .|. m) (w .&. complement m) r' = w `xor` ((-(oneIf f) `xor` w) .&. m); --- | Formalizes +-- | Formalizes powerOfTwoCorrect :: SWord32 -> SBool powerOfTwoCorrect v = f .== s where f = (v ./= 0) .&& ((v .&. (v-1)) .== 0); diff --git a/Documentation/SBV/Examples/BitPrecise/Legato.hs b/Documentation/SBV/Examples/BitPrecise/Legato.hs --- a/Documentation/SBV/Examples/BitPrecise/Legato.hs +++ b/Documentation/SBV/Examples/BitPrecise/Legato.hs @@ -8,7 +8,7 @@ -- -- An encoding and correctness proof of Legato's multiplier in Haskell. Bill Legato came -- up with an interesting way to multiply two 8-bit numbers on Mostek, as described here: --- +-- -- -- Here's Legato's algorithm, as coded in Mostek assembly: -- diff --git a/Documentation/SBV/Examples/BitPrecise/PrefixSum.hs b/Documentation/SBV/Examples/BitPrecise/PrefixSum.hs --- a/Documentation/SBV/Examples/BitPrecise/PrefixSum.hs +++ b/Documentation/SBV/Examples/BitPrecise/PrefixSum.hs @@ -9,7 +9,7 @@ -- The PrefixSum algorithm over power-lists and proof of -- the Ladner-Fischer implementation. -- See --- and . +-- and . ----------------------------------------------------------------------------- {-# LANGUAGE CPP #-} 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 @@ -110,7 +110,7 @@ -- -- >>> notFair 10 -- Fairness is violated at bound: 10 --- P1: [Idle,Idle,Idle,Idle,Ready,Critical,Idle,Ready,Critical,Critical] +-- P1: [Idle,Idle,Idle,Idle,Ready,Critical,Critical,Critical,Idle,Ready] -- P2: [Idle,Ready,Ready,Ready,Ready,Ready,Ready,Ready,Ready,Ready] -- Ts: [1,1,1,1,1,1,1,1,1,1] -- 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 @@ -127,20 +127,18 @@ >>> prove $ (qe (\(Forall x) -> p x) .|| qe (\(Forall x) -> q x)) .<=> qe (\(Forall x) -> p x .|| q x) Falsifiable. Counter-example: P :: U -> Bool - P U_1 = False - P U_2 = True - P _ = True + P U_1 = True + P _ = False Q :: U -> Bool - Q U_1 = True - Q U_2 = False + Q U_1 = False Q _ = True -The solver found us a falsifying instance: Pick a domain with at least three elements. We'll call -the first element @U_1@, and the second element @U_2@, without naming the others. +The solver found us a falsifying instance: Pick a domain with at least two elements. We'll call +the first element @U_1@, without naming the others. -Arrange so that \(P\) is false on @U_1@ true everywhere else. -Also arrange so that \(Q\) is false for @U_2@ but true for everything else. +Arrange so that \(P\) is true on @U_1@ but false everywhere else. +Also arrange so that \(Q\) is false for @U_1@ but true for everything else. With this assignment, the right hand side of our conjecture 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 @@ -157,29 +157,29 @@ -- -- >>> roundingAdd -- Satisfiable. Model: --- rm = RoundTowardPositive :: RoundingMode --- x = -2.341805e-38 :: Float --- y = -1.83671e-40 :: Float +-- rm = RoundTowardZero :: RoundingMode +-- x = 1.5312457e17 :: Float +-- y = -9.009385e15 :: Float -- -- (Note that depending on your version of Z3, you might get a different result.) -- Unfortunately Haskell floats do not allow computation with arbitrary rounding modes, but SBV's -- 'SFloatingPoint' type does. We have: -- --- >>> sat $ \x -> x .== (fpAdd sRoundTowardPositive (-2.341805e-38) (-1.83671e-40) :: SFloat) +-- >>> sat $ \x -> x .== (fpAdd sRoundTowardZero 1.5312457e17 (-9.009385e15) :: SFloat) -- Satisfiable. Model: --- s0 = -2.360172e-38 :: Float --- >>> (-2.360172e-38) + (-1.83671e-40 :: Float) --- -2.378539e-38 +-- s0 = 1.4411518e17 :: Float +-- >>> 1.5312457e17 + (-9.009385e15 :: Float) +-- 1.4411519e17 -- --- We can see why these two results are indeed different: The 'RoundTowardPositive --- (which rounds towards positive infinity) produces a larger result. If we do the computation +-- We can see why these two results are indeed different: The 'RoundTowardZero' +-- (which rounds towards zero) produces a smaller result. If we do the computation -- using double precision, we get: -- --- >>> (-2.360172e-38) + (-1.83671e-40 :: Double) --- -2.3785390999999997e-38 +-- >>> 1.5312457e17 + (-9.009385e15 :: Double) +-- 1.44115185e17 -- --- we see that the "more precise" result is larger than what the 'Float' value is, justifying the --- larger value with 'RoundTowardPositive. A more detailed study is beyond our current scope, so we'll +-- we see that the "more precise" result is smaller than what the 'Float' value is, justifying the +-- smaller value with 'RoundTowardZero'. A more detailed study is beyond our current scope, so we'll -- merely note that floating point representation and semantics is indeed a thorny subject. roundingAdd :: IO SatResult roundingAdd = sat $ do m :: SRoundingMode <- free "rm" diff --git a/Documentation/SBV/Examples/Misc/SetAlgebra.hs b/Documentation/SBV/Examples/Misc/SetAlgebra.hs --- a/Documentation/SBV/Examples/Misc/SetAlgebra.hs +++ b/Documentation/SBV/Examples/Misc/SetAlgebra.hs @@ -348,7 +348,7 @@ >>> prove $ \(a :: SI) b c -> a `isSubsetOf` (b `union` c) .=> a `isSubsetOf` b .&& a `isSubsetOf` c Falsifiable. Counter-example: - s0 = {2} :: {Integer} + s0 = U :: {Integer} s1 = U :: {Integer} s2 = U - {2} :: {Integer} diff --git a/Documentation/SBV/Examples/ProofTools/Strengthen.hs b/Documentation/SBV/Examples/ProofTools/Strengthen.hs --- a/Documentation/SBV/Examples/ProofTools/Strengthen.hs +++ b/Documentation/SBV/Examples/ProofTools/Strengthen.hs @@ -10,7 +10,7 @@ -- can be coded using SBV, using induction. We also demonstrate the use of -- invariant strengthening. -- --- This example comes from Bradley's [Understanding IC3](http://theory.stanford.edu/~arbrad/papers/Understanding_IC3.pdf) paper, +-- This example comes from Bradley's [Understanding IC3](https://doi.org/10.1007/978-3-642-31612-8_1) paper, -- which considers the following two programs: -- -- @ 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 @@ -128,8 +128,8 @@ -- Searching at depth: 4 -- Searching at depth: 5 -- Searching at depth: 6 --- Found: [10,10,11,9,14,6] -- Found: [10,10,9,11,14,6] +-- Found: [10,10,11,9,14,6] -- There are no more solutions. example :: IO () example = search initBoard finalBoard diff --git a/Documentation/SBV/Examples/Puzzles/Rubik.hs b/Documentation/SBV/Examples/Puzzles/Rubik.hs new file mode 100644 --- /dev/null +++ b/Documentation/SBV/Examples/Puzzles/Rubik.hs @@ -0,0 +1,692 @@ +----------------------------------------------------------------------------- +-- | +-- Module : Documentation.SBV.Examples.Puzzles.Rubik +-- Copyright : (c) Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bounded shortest and two-phase solutions for a 3x3 Rubik's Cube. The face-turn metric +-- counts each quarter-turn, inverse quarter-turn, and half-turn as one move. +-- Centers stay fixed; slice moves, wide turns, and whole-cube rotations are +-- unsupported. Inputs can be scrambles of the solved cube or facelets +-- transcribed from a physical cube; see 'physicalCube'. +-- Inputs are assumed legal; transcription errors are not diagnosed and may +-- instead exhaust a search bound. +-- +-- Facelets use Kociemba's order U1..U9, R1..R9, F1..F9, D1..D9, L1..L9, +-- B1..B9, with this net (each face is viewed from outside): +-- +-- @ +-- U1 U2 U3 +-- U4 U5 U6 +-- U7 U8 U9 +-- L1 L2 L3 F1 F2 F3 R1 R2 R3 B1 B2 B3 +-- L4 L5 L6 F4 F5 F6 R4 R5 R6 B4 B5 B6 +-- L7 L8 L9 F7 F8 F9 R7 R8 R9 B7 B8 B9 +-- D1 D2 D3 +-- D4 D5 D6 +-- D7 D8 D9 +-- @ +-- +-- The coordinates are right-handed: +x = R, +y = U, +z = F. Clockwise, +-- looking at a face, means -90 degrees about its outward normal, including +-- the negative-axis faces D, L, and B. See +-- for the facelet convention. +-- +-- With fixed centers, every cubie has a unique set of colors, so colors +-- determine a legal cube's state. We ignore invisible center-piece rotations. +-- 'isSolved' therefore compares colors with the original solved coloring. +-- +-- A successful 'solveWith' result is shortest: every smaller positive depth was +-- unsatisfiable, and depth zero was checked concretely. The depth bound is +-- only a limit; the search stops as soon as it finds a solution. A bound +-- failure says nothing about greater depths. +-- 'solveTwoPhaseWith' instead supplies an intermediate target and restricted +-- moves for the second phase, accepting a solution without proving optimality. +----------------------------------------------------------------------------- + +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE TemplateHaskell #-} +{-# LANGUAGE TypeApplications #-} + +{-# OPTIONS_GHC -Wall -Werror #-} + +module Documentation.SBV.Examples.Puzzles.Rubik where + +import Control.Monad (foldM, when) +import Data.List (elemIndex, intercalate, sortOn) + +import qualified Data.List as List (foldl') + +import Data.SBV +import Data.SBV.Control + +-- | The six faces of the cube. This enumeration is separate from facelet +-- storage order, which follows U R F D L B. +data Face = U | D | L | R | F | B + deriving (Eq, Ord, Show, Enum, Bounded) + +-- | The three nonidentity turns of a face: clockwise and counterclockwise +-- quarter-turns rotate by 90 degrees; a half-turn rotates by 180 degrees. +data Turn = Clockwise | HalfTurn | Counterclockwise + deriving (Eq, Ord, Show, Enum, Bounded) + +-- | One move in the face-turn metric. +data Move = Move Face Turn + deriving (Eq, Ord, Show) + +-- | Solved colors: U white, R red, F green, D yellow, L orange, B blue. +data Color = White | Red | Green | Yellow | Orange | Blue + deriving (Eq, Ord, Show) + +-- | Symbolic faces, turns, and colors are SMT enumerations with named values. +mkSymbolic [''Face, ''Turn, ''Color] + +-- | A cube represented by 54 facelet colors in U R F D L B order. +-- Start with 'solvedCube' and use 'applyMove' or 'applyMoves' to obtain +-- reachable positions. +newtype Cube = Cube [Color] + deriving (Eq, Ord, Show) + +-- | Facelets in U R F D L B order. +cubeColors :: Cube -> [Color] +cubeColors (Cube cs) = cs + +-- | Original solved coloring. +solvedCube :: Cube +solvedCube = Cube (concatMap (replicate 9) [White, Red, Green, Yellow, Orange, Blue]) + +-- | A scrambled physical cube, transcribed face by face. Hold it with the +-- white center on top and the green center facing you when applying moves. +-- The six grids below follow the U R F D L B storage order. +-- See 'solveTwoPhase' for the manual search example and 'physicalSolution' +-- for a recorded solution. Shortest-path search with 'solveWith' is impractical +-- for this scramble. +-- +-- >>> putStr (renderCube physicalCube) +-- U +-- b g w +-- r w g +-- b y g +-- L F R B +-- y w o w b y r w o g r r +-- y o b r g w o r r y b g +-- r y y b b o g w w r g b +-- D +-- o o y +-- o y b +-- w o g +-- w=white r=red g=green y=yellow o=orange b=blue +physicalCube :: Cube +physicalCube = Cube $ concat + [ -- UP + [ Blue, Green, White + , Red, White, Green + , Blue, Yellow, Green + ] + , -- RIGHT + [ Red, White, Orange + , Orange, Red, Red + , Green, White, White + ] + , -- FRONT + [ White, Blue, Yellow + , Red, Green, White + , Blue, Blue, Orange + ] + , -- DOWN + [ Orange, Orange, Yellow + , Orange, Yellow, Blue + , White, Orange, Green + ] + , -- LEFT + [ Yellow, White, Orange + , Yellow, Orange, Blue + , Red, Yellow, Yellow + ] + , -- BACK + [ Green, Red, Red + , Yellow, Blue, Green + , Red, Green, Blue + ] + ] + +-- | A solution for 'physicalCube', found by a manual two-phase Z3 run. +-- The first line has the twelve phase-one moves; the second has the eighteen +-- phase-two moves. Hold the cube with white up and green front throughout. +-- This is not claimed to be shortest. The doctest only replays the recorded +-- moves, so it does not repeat the expensive search. +-- +-- >>> isSolved (applyMoves physicalSolution physicalCube) +-- True +physicalSolution :: [Move] +physicalSolution = either error id $ parseMoves $ unwords + [ "L2 F L U F R' B R2 D2 R F2 R'" + , "F2 B2 U2 F2 R2 U B2 D' F2 D' R2 D2 B2 U2 L2 B2 D2 L2" + ] + +-- | Compare the facelets with the fixed solved coloring. +-- +-- >>> isSolved solvedCube +-- True +-- >>> isSolved (applyMove (Move R Clockwise) solvedCube) +-- False +isSolved :: Cube -> Bool +isSolved = (== solvedCube) + +-- | A destination-to-source permutation: new[i] = old[p[i]]. +newtype Perm = Perm [Int] + +-- | Apply a permutation to exactly 54 values, including distinct test labels. +-- +-- >>> take 3 (permute (Perm [53,52..0]) [0..53 :: Int]) +-- [53,52,51] +permute :: Perm -> [a] -> [a] +permute (Perm p) xs + | length xs == 54 = map (xs !!) p + | True = error "Rubik.permute: expected exactly 54 facelets" + +-- | Integer vector @(x, y, z)@ for facelet positions and directions. +-- Positive axes point right, up, and front, respectively. +type Vec = (Int, Int, Int) + +-- | Add two vectors componentwise. +add :: Vec -> Vec -> Vec +add (a, b, c) (x, y, z) = (a+x, b+y, c+z) + +-- | Multiply each component of a vector by an integer. +scale :: Int -> Vec -> Vec +scale k (x, y, z) = (k*x, k*y, k*z) + +-- | Dot product, used to select the layer belonging to a face. +dot :: Vec -> Vec -> Int +dot (a, b, c) (x, y, z) = a*x + b*y + c*z + +-- | Cross product in the right-handed cube coordinate system. +cross :: Vec -> Vec -> Vec +cross (a, b, c) (x, y, z) = (b*z-c*y, c*x-a*z, a*y-b*x) + +-- | Outward normal, screen-right, and screen-up unit vectors, viewed from +-- outside the face. These orient each face's grid in the documented net. +-- +-- >>> basis B +-- ((0,0,-1),(-1,0,0),(0,1,0)) +basis :: Face -> (Vec, Vec, Vec) +basis U = (( 0, 1, 0), ( 1, 0, 0), ( 0, 0,-1)) +basis D = (( 0,-1, 0), ( 1, 0, 0), ( 0, 0, 1)) +basis L = ((-1, 0, 0), ( 0, 0, 1), ( 0, 1, 0)) +basis R = (( 1, 0, 0), ( 0, 0,-1), ( 0, 1, 0)) +basis F = (( 0, 0, 1), ( 1, 0, 0), ( 0, 1, 0)) +basis B = (( 0, 0,-1), (-1, 0, 0), ( 0, 1, 0)) + +-- | Positions and outward normals of the 54 facelets, in U R F D L B order. +-- Position and normal together distinguish stickers on the same cubie. +-- +-- NB. Keep the explicit U R F D L B storage order: [minBound .. maxBound] follows +-- the different Face constructor order U D L R F B. Solved colors, rendering, +-- and the reference fixtures all depend on this storage order. +-- +-- For example, U9 and R1 share a corner but face in different directions: +-- +-- >>> facelets !! 8 +-- ((1,1,1),(0,1,0)) +-- >>> facelets !! 9 +-- ((1,1,1),(1,0,0)) +facelets :: [(Vec, Vec)] +facelets = [(n `add` scale (c-1) r `add` scale (1-row) u, n) | f <- [U, R, F, D, L, B], let (n, r, u) = basis f, row <- [0..2], c <- [0..2]] + +-- | Generate a clockwise quarter-turn from integer geometry, rotating both +-- sticker positions and normals in the selected layer. The face's own grid +-- rotates clockwise; these are the source indexes for F1 through F9: +-- +-- >>> take 9 (drop 18 (permute (quarterTurn F) [0..53 :: Int])) +-- [24,21,18,25,22,19,26,23,20] +quarterTurn :: Face -> Perm +quarterTurn f = Perm (map snd (sortOn fst destinations)) + where (axis, _, _) = basis f + + -- Rodrigues' formula for -90 degrees about a unit coordinate axis. + rotateVector v = scale (dot axis v) axis `add` cross v axis + turn (p,n) | dot axis p == 1 = (rotateVector p, rotateVector n) + | True = (p,n) + + destination sticker = case elemIndex (turn sticker) facelets of + Just i -> i + Nothing -> error "Rubik.quarterTurn: invalid geometry" + + destinations = [(destination sticker, i) | (i, sticker) <- zip [0..] facelets] + +-- | All eighteen moves, enumerating each face and its three turns. +-- +-- >>> renderMoves allMoves +-- "U U2 U' D D2 D' L L2 L' R R2 R' F F2 F' B B2 B'" +allMoves :: [Move] +allMoves = [Move f t | f <- [minBound .. maxBound], t <- [minBound .. maxBound]] + +-- | Shared permutations for all eighteen moves. Half-turns and inverse +-- quarter-turns are obtained by composing the generated quarter-turns. +moveTables :: [(Move, Perm)] +moveTables = [(m, Perm (iterate (permute (quarterTurn f)) [0..53] !! count t)) | m@(Move f t) <- allMoves] + where count Clockwise = 1 + count HalfTurn = 2 + count Counterclockwise = 3 + +-- | Permutation for a move, derived from integer geometry. +-- A U half-turn reverses the order of the nine stickers on that face: +-- +-- >>> take 9 (permute (movePerm (Move U HalfTurn)) [0..53 :: Int]) +-- [8,7,6,5,4,3,2,1,0] +movePerm :: Move -> Perm +movePerm m = case lookup m moveTables of + Just p -> p + Nothing -> error "Rubik.movePerm: missing move" + +-- | Turn one face. +-- +-- A right quarter-turn brings green stickers to the right column of U: +-- +-- >>> take 9 (cubeColors (applyMove (Move R Clockwise) solvedCube)) +-- [White,White,Green,White,White,Green,White,White,Green] +applyMove :: Move -> Cube -> Cube +applyMove m (Cube cs) = Cube (permute (movePerm m) cs) + +-- | Apply moves from left to right. +-- +-- >>> let scramble = [Move R Clockwise, Move U HalfTurn] +-- >>> isSolved (applyMoves (scramble ++ invertMoves scramble) solvedCube) +-- True +applyMoves :: [Move] -> Cube -> Cube +applyMoves ms c = List.foldl' (flip applyMove) c ms + +-- | Undo one move. +-- +-- A half-turn is its own inverse: +-- +-- >>> inverseMove (Move R HalfTurn) +-- Move R HalfTurn +inverseMove :: Move -> Move +inverseMove (Move f t) = Move f $ case t of + Clockwise -> Counterclockwise + HalfTurn -> HalfTurn + Counterclockwise -> Clockwise + +-- | Undo a sequence, reversing its order as well as its turns. +-- +-- >>> renderMoves (invertMoves [Move R Clockwise, Move U HalfTurn]) +-- "U2 R'" +invertMoves :: [Move] -> [Move] +invertMoves = reverse . map inverseMove + +-- | A symbolic cube uses ordinary lists: all facelet indexes are static; +-- only the choice of move is symbolic. +type SCube = [SColor] + +-- | A symbolic move chooses a face and a turn directly. Their datatypes +-- admit only valid choices, so no numeric codes or domain constraints are needed. +data SMove = SMove { moveFace :: SFace -- ^ Face to turn. + , moveTurn :: STurn -- ^ Direction and amount of rotation. + } + +-- | Adjacent equal faces combine or cancel. Opposite faces commute, so keep +-- U before D, L before R, and F before B. These rules preserve a shortest +-- solution and also exclude R L R, which reduces to R2 L and then L R2. +-- +-- Opposite faces L and R are allowed only in that order: +-- +-- >>> import Data.SBV (unliteral) +-- >>> unliteral (canonicalPair (SMove sL sClockwise) (SMove sR sClockwise)) +-- Just True +-- >>> unliteral (canonicalPair (SMove sR sClockwise) (SMove sL sClockwise)) +-- Just False +canonicalPair :: SMove -> SMove -> SBool +canonicalPair (SMove f _) (SMove g _) = f ./= g .&& sNot (sOr reversedOpposites) + where reversedOpposites = [f .== literal a .&& g .== literal b | (a,b) <- [(D,U), (R,L), (B,F)]] + +-- | Lift the concrete permutations by selecting the named face and turn. +-- +-- With concrete choices, the symbolic expressions evaluate to colors. +-- Here we select R clockwise: +-- +-- >>> import Data.SBV (literal, unliteral) +-- >>> let initial = map literal (cubeColors solvedCube) +-- >>> map unliteral (take 9 (step (SMove sR sClockwise) initial)) +-- [Just White,Just White,Just Green,Just White,Just White,Just Green,Just White,Just White,Just Green] +step :: SMove -> SCube -> SCube +step (SMove f t) cs = choose f [(face, choose t [(turn, permute (movePerm (Move face turn)) cs) + | turn <- [minBound .. maxBound]]) + | face <- [minBound .. maxBound]] + where choose :: SymVal a => SBV a -> [(a, SCube)] -> SCube + choose _ [] = error "Rubik.step: empty choice" + choose v ((_, x):xs) = foldr (\(value, ys) zs -> zipWith (ite (v .== literal value)) ys zs) x xs + +-- | Depth bound, progress reporting, and canonical pruning. +-- Disable pruning to compare searches in small tests. +data SearchOptions = SearchOptions + { maxDepth :: Int -- ^ Maximum solution length in the face-turn metric. + , showProgress :: Bool -- ^ Print the depth before each satisfiability check. + , usePruning :: Bool -- ^ Restrict adjacent moves using 'canonicalPair'. + } deriving Show + +-- | Quiet search with pruning. +defaultOptions :: Int -> SearchOptions +defaultOptions n = SearchOptions n False True + +-- | A solution, or exhaustion of the supplied depth bound. 'solveWith' +-- guarantees a shortest solution; 'solveWithinWith' accepts any solution. +data SolveResult = Solved [Move] | NoSolutionWithin Int deriving (Eq, Show) + +-- | Solve a legal cube with the chosen solver. +-- A negative depth bound raises an error. +-- +-- Each iteration extends the previous state by one symbolic move, then pushes +-- a temporary goal asserting the solved coloring. On unsat we pop only that +-- goal and extend again. Move declarations and pruning constraints stay +-- outside the temporary context. On sat we extract the moves; any other solver result +-- is an error, as in the other puzzle examples. +-- +-- >>> import Data.SBV (z3) +-- >>> solveWith z3 (defaultOptions 1) (applyMove (Move F HalfTurn) solvedCube) +-- Solved [Move F HalfTurn] +solveWith :: SMTConfig -> SearchOptions -> Cube -> IO SolveResult +solveWith cfg opts initial + | maxDepth opts < 0 = error "Rubik.solveWith: negative depth bound" + | isSolved initial = pure (Solved []) + | maxDepth opts == 0 = pure (NoSolutionWithin 0) + | True = runSMTWith cfg $ query $ extend 1 [] (map literal (cubeColors initial)) + where extend depth previous cs = do + f <- freshVar ("face_" ++ show depth) + t <- freshVar ("turn_" ++ show depth) + let m = SMove f t + moves = m : previous -- Most recent move first; reverse only for extraction. + next = step m cs + when (usePruning opts) $ case previous of + p:_ -> constrain (canonicalPair p m) + [] -> pure () + when (showProgress opts) $ io $ putStrLn $ "Checking depth " ++ show depth + push 1 + constrain (sAnd (zipWith (.==) next (map literal (cubeColors solvedCube)))) + status <- checkSat + case status of + Unsat | depth == maxDepth opts -> pure (NoSolutionWithin depth) + | True -> pop 1 >> extend (depth+1) moves next + Sat -> Solved <$> mapM extract (reverse moves) + other -> error $ "Rubik.solveWith: unexpected solver result: " ++ show other + extract (SMove mf mt) = Move <$> getValue mf <*> getValue mt + +-- | Solve a scramble using Z3. +-- +-- >>> solveScramble (defaultOptions 0) [] +-- Solved [] +-- >>> solveScramble (defaultOptions 1) [Move R Clockwise] +-- Solved [Move R Counterclockwise] +-- >>> solveScramble (defaultOptions 1) [Move R Clockwise, Move U Clockwise] +-- NoSolutionWithin 1 +-- >>> solveScramble (defaultOptions 2) [Move R Clockwise, Move U Clockwise] +-- Solved [Move U Counterclockwise,Move R Counterclockwise] +solveScramble :: SearchOptions -> [Move] -> IO SolveResult +solveScramble opts ms = solveWith z3 opts (applyMoves ms solvedCube) + +-- | Forget which of two opposite colors a sticker has. The three remaining +-- colors identify the U/D, F/B, and L/R axes. Phase one needs only these +-- classes; replaying its moves on the original cube restores full information. +-- +-- >>> take 9 (cubeColors (phaseOneCube solvedCube)) +-- [White,White,White,White,White,White,White,White,White] +-- >>> phaseOneCube (applyMove (Move U HalfTurn) solvedCube) == phaseOneCube solvedCube +-- True +phaseOneCube :: Cube -> Cube +phaseOneCube = Cube . map axisColor . cubeColors + where axisColor Yellow = White + axisColor Orange = Red + axisColor Blue = Green + axisColor c = c + +-- | Phase-one target on a cube projected by 'phaseOneCube'. All U/D stickers +-- must have the U/D color class. This orients the corners and the eight U/D +-- edges and excludes middle-layer edges from those layers. The four remaining +-- edges must present their F/B stickers toward F/B, orienting them as well. +-- Centers are omitted because moves never change them. +-- +-- These are precisely the conditions for the subgroup generated by +-- 'phaseTwoMoves'; see . +-- +-- >>> import Data.SBV (literal, unliteral) +-- >>> let ready = unliteral . phaseOneGoal . map literal . cubeColors . phaseOneCube +-- >>> ready solvedCube +-- Just True +-- >>> ready (applyMove (Move R Clockwise) solvedCube) +-- Just False +-- >>> ready (applyMove (Move R HalfTurn) solvedCube) +-- Just True +-- +-- The recorded physical solution reaches this target after twelve moves: +-- +-- >>> ready (applyMoves (take 12 physicalSolution) physicalCube) +-- Just True +phaseOneGoal :: SCube -> SBool +phaseOneGoal cs = sAnd ([cs !! i .== sWhite | i <- [0,1,2,3,5,6,7,8,27,28,29,30,32,33,34,35]] + ++ [cs !! i .== sGreen | i <- [21,23,48,50]]) + +-- | Moves preserving the phase-one target: arbitrary U/D turns and half-turns +-- of the four side faces. Together they can solve every legal phase-one state. +-- +-- >>> renderMoves phaseTwoMoves +-- "U U2 U' D D2 D' L2 R2 F2 B2" +phaseTwoMoves :: [Move] +phaseTwoMoves = [m | m@(Move f t) <- allMoves, f `elem` [U,D] || t == HalfTurn] + +-- | Find any sequence within the bound using the supplied moves and target. +-- One query allows up to the bound's number of moves, followed by inactive +-- slots that leave the cube unchanged. Active slots form a prefix; extracting +-- only those slots gives the solution without proving shorter lengths +-- impossible. Pruning applies only between active moves. +-- A negative bound is an error; non-sat/unsat solver results also raise errors. +-- +-- >>> import Data.SBV (z3) +-- >>> solveWithinWith z3 (defaultOptions 1) phaseTwoMoves phaseOneGoal (phaseOneCube solvedCube) +-- Solved [] +solveWithinWith :: SMTConfig -> SearchOptions -> [Move] -> (SCube -> SBool) -> Cube -> IO SolveResult +solveWithinWith cfg opts allowed goal initial + | maxDepth opts < 0 = error "Rubik.solveWithinWith: negative depth bound" + | unliteral (goal start) == Just True = pure (Solved []) + | maxDepth opts == 0 = pure (NoSolutionWithin 0) + | True = runSMTWith cfg $ do + (revMoves, final) <- foldM extend ([], start) [1 .. maxDepth opts] + let moves = reverse revMoves + constrain (goal final) + query $ do + when (showProgress opts) $ io $ putStrLn $ "Checking up to " ++ show (maxDepth opts) ++ " moves" + status <- checkSat + case status of + Unsat -> pure (NoSolutionWithin (maxDepth opts)) + Sat -> do active <- mapM (getValue . fst) moves + let n = length (takeWhile id active) + Solved <$> mapM (extract . snd) (take n moves) + other -> error $ "Rubik.solveWithinWith: unexpected solver result: " ++ show other + where start = map literal (cubeColors initial) + extend (previous, cs) depth = do + f <- free ("face_" ++ show depth) + t <- free ("turn_" ++ show depth) + active <- free ("active_" ++ show depth) + let m = SMove f t + constrain (active .=> sOr [f .== literal face .&& t .== literal turn | Move face turn <- allowed]) + case previous of + (wasActive, p):_ -> do + constrain (active .=> wasActive) + when (usePruning opts) $ constrain (active .=> canonicalPair p m) + [] -> pure () + pure ((active, m) : previous, zipWith (ite active) (step m cs) cs) + extract (SMove f t) = Move <$> getValue f <*> getValue t + +-- | Two sequences forming a solution, or the phase whose bound was exhausted. +-- A phase-two failure retains the phase-one sequence so that the intermediate +-- cube can be retried with a larger bound. It does not rule out solutions +-- through other intermediate cubes, nor solutions within the combined bounds. +data TwoPhaseResult = TwoPhaseSolved [Move] [Move] + | PhaseOneExhausted Int + | PhaseTwoExhausted [Move] Int + deriving (Eq, Show) + +-- | Let Z3 choose every move, using a human-supplied intermediate target. +-- First orient all pieces and put middle-layer edges in the middle layer; +-- then solve using 'phaseTwoMoves'. The first phase's result is applied to the +-- full-color input before starting the second phase. No shortest-path claim +-- is made, either for the individual phases or their concatenation. +-- +-- The example crosses both phases. Check the resulting cube rather than a +-- particular sequence, since Z3 may choose different valid solutions. +-- +-- >>> import Data.SBV (z3) +-- >>> let cube = applyMoves [Move U Clockwise, Move R Clockwise] solvedCube +-- >>> TwoPhaseSolved first second <- solveTwoPhaseWith z3 (defaultOptions 1) (defaultOptions 2) cube +-- >>> isSolved (applyMoves (first ++ second) cube) +-- True +solveTwoPhaseWith :: SMTConfig -> SearchOptions -> SearchOptions -> Cube -> IO TwoPhaseResult +solveTwoPhaseWith cfg firstOpts secondOpts initial + | maxDepth firstOpts < 0 || maxDepth secondOpts < 0 = error "Rubik.solveTwoPhaseWith: negative depth bound" + | True = do + when (showProgress firstOpts) $ putStrLn "Phase 1: orientations and middle-layer edges" + first <- solveWithinWith cfg firstOpts allMoves phaseOneGoal (phaseOneCube initial) + case first of + NoSolutionWithin n -> pure (PhaseOneExhausted n) + Solved ms -> do + when (showProgress firstOpts) $ putStrLn $ "Phase 1: " ++ renderMoves ms + when (showProgress secondOpts) $ putStrLn "Phase 2: solve with U/D turns and side half-turns" + let middle = applyMoves ms initial + goal cs = sAnd (zipWith (.==) cs (map literal (cubeColors solvedCube))) + second <- solveWithinWith cfg secondOpts phaseTwoMoves goal middle + pure $ case second of + NoSolutionWithin n -> PhaseTwoExhausted ms n + Solved ns -> TwoPhaseSolved ms ns + +-- | Two-phase search using Z3's SAT engine. The tactic simplifies the formula, +-- eliminates conditionals over colors, and translates finite enumerations to +-- bit-vectors before bit-blasting. Haskell still uses named faces, turns, and +-- colors; this is only a choice of Z3's solving machinery, not a source of +-- cube-solving move sequences. +-- +-- To run a fresh search for 'physicalCube', with separate bounds for the two +-- phases and progress reporting: +-- +-- @ +-- solveTwoPhase +-- (defaultOptions 12) {showProgress = True} +-- (defaultOptions 18) {showProgress = True} +-- physicalCube +-- @ +-- +-- Success returns @TwoPhaseSolved first second@; apply @first ++ second@ to +-- solve the input cube. Use 'solveTwoPhaseWith' to supply a solver configuration. +-- 'physicalSolution' holds a recorded solution from a previous run. +-- The physical-cube search can take minutes, so the call above is a manual +-- example, not a doctest. Doctests use tiny searches or replay recorded moves. +-- +-- >>> solveTwoPhase (defaultOptions 0) (defaultOptions 0) solvedCube +-- TwoPhaseSolved [] [] +solveTwoPhase :: SearchOptions -> SearchOptions -> Cube -> IO TwoPhaseResult +solveTwoPhase = solveTwoPhaseWith z3 {satCmd = "(check-sat-using (then simplify elim-term-ite solve-eqs dt2bv simplify bit-blast sat))"} + +-- | Parse whitespace-separated uppercase face turns, optionally followed by +-- ASCII apostrophe or 2. Empty input is accepted; lowercase, R2', and commas +-- are rejected with a token and its one-based position in the message. +-- +-- >>> parseMoves "R U R' U' F2" +-- Right [Move R Clockwise,Move U Clockwise,Move R Counterclockwise,Move U Counterclockwise,Move F HalfTurn] +-- >>> parseMoves "R2'" +-- Left "Token 1 \"R2'\": use R2 for a half-turn" +parseMoves :: String -> Either String [Move] +parseMoves = traverse parse . zip [(1::Int)..] . words + where parse (i, token) = case token of + c:suffix | Just f <- lookup c [('U',U),('D',D),('L',L),('R',R),('F',F),('B',B)] + , Just t <- lookup suffix [("",Clockwise),("2",HalfTurn),("'",Counterclockwise)] + -> Right (Move f t) + _ -> Left ("Token " ++ show i ++ " " ++ show token ++ ": " ++ reason token) + + reason token + | any (`elem` ",;:/|") token = "use whitespace between moves, not punctuation separators" + | c:_ <- token, c `elem` "MES" = "unsupported slice move (M, E, S)" + | c:_ <- token, c `elem` "xyzXYZ" = "unsupported whole-cube rotation (x, y, z)" + | c:w:_ <- token, c `elem` "UDLRFBudlrfb", w `elem` "wW" = "unsupported wide turn" + | c:_ <- token, c `elem` "udlrfb" = "lowercase notation is unsupported; lowercase faces denote wide turns" + | [c,'2','\''] <- token, c `elem` "UDLRFB" = "use " ++ [c,'2'] ++ " for a half-turn" + | True = "expected U, D, L, R, F, or B with optional ' or 2; separate moves with whitespace" + +-- | Canonical notation, separated by single spaces. +-- +-- >>> renderMoves [Move R Clockwise, Move U HalfTurn, Move F Counterclockwise] +-- "R U2 F'" +renderMoves :: [Move] -> String +renderMoves = unwords . map render + where render (Move f t) = show f ++ case t of + Clockwise -> "" + HalfTurn -> "2" + Counterclockwise -> "'" + +-- | ASCII net in the documented orientation, with a color legend. +-- +-- >>> putStr (renderCube solvedCube) +-- U +-- w w w +-- w w w +-- w w w +-- L F R B +-- o o o g g g r r r b b b +-- o o o g g g r r r b b b +-- o o o g g g r r r b b b +-- D +-- y y y +-- y y y +-- y y y +-- w=white r=red g=green y=yellow o=orange b=blue +renderCube :: Cube -> String +renderCube (Cube cs) = unlines $ + [" U"] ++ map (" " ++) (rows 0) + ++ ["L F R B"] + ++ [intercalate " " [rows f !! r | f <- [4,2,1,5]] | r <- [0..2]] + ++ [" D"] ++ map (" " ++) (rows 3) + ++ ["w=white r=red g=green y=yellow o=orange b=blue"] + where rows f = [unwords [[colorChar (cs !! (9*f+3*r+c))] | c <- [0..2]] | r <- [0..2]] + colorChar White = 'w' + colorChar Red = 'r' + colorChar Green = 'g' + colorChar Yellow = 'y' + colorChar Orange = 'o' + colorChar Blue = 'b' + +-- | Print a scramble, its cube, search progress, and the solution. +-- This scramble turns three different faces, including a half-turn. Although +-- the depth bound is ten, the search stops when it finds a solution at three. +-- +-- >>> demo 10 "R U F2" +-- Scramble: R U F2 +-- U +-- w w w +-- w w w +-- b y y +-- L F R B +-- g g r y g g o b b o o o +-- o o r y g g o r r w b b +-- o o w r r r y r r w b b +-- D +-- g g g +-- y y b +-- y y b +-- w=white r=red g=green y=yellow o=orange b=blue +-- Checking depth 1 +-- Checking depth 2 +-- Checking depth 3 +-- Solution (3 moves): F2 U' R' +demo :: Int -> String -> IO () +demo bound input = case parseMoves input of + Left err -> error err + Right ms -> do + let initial = applyMoves ms solvedCube + putStrLn $ "Scramble: " ++ renderMoves ms + putStr (renderCube initial) + result <- solveWith z3 (defaultOptions bound) {showProgress = True} initial + case result of + Solved solution -> do let n = length solution + unit = if n == 1 then " move" else " moves" + putStrLn $ "Solution (" ++ show n ++ unit ++ "): " ++ renderMoves solution + other -> print other diff --git a/Documentation/SBV/Examples/Strings/RegexCrossword.hs b/Documentation/SBV/Examples/Strings/RegexCrossword.hs --- a/Documentation/SBV/Examples/Strings/RegexCrossword.hs +++ b/Documentation/SBV/Examples/Strings/RegexCrossword.hs @@ -6,7 +6,7 @@ -- Maintainer: erkokl@gmail.com -- Stability : experimental -- --- This example solves regex crosswords from +-- This example solves regex crosswords from ----------------------------------------------------------------------------- {-# LANGUAGE OverloadedStrings #-} @@ -60,7 +60,7 @@ Unsat -> error "There are no solutions to this puzzle!" Sat -> mapM getValue rows --- | Solve +-- | Solve -- -- >>> puzzle1 -- ["ATO","WEL"] @@ -75,7 +75,7 @@ , R.oneOf "BORF" * R.All -- [BORF]. ] --- | Solve +-- | Solve -- -- >>> puzzle2 -- ["WA","LK","ER"] @@ -90,7 +90,7 @@ , R.KPlus (R.oneOf "RANK") -- [RANK]+ ] --- | Solve +-- | Solve -- -- >>> puzzle3 -- ["RATS","ABUT","TUBA","STAR"] diff --git a/Documentation/SBV/Examples/TP/Basics.hs b/Documentation/SBV/Examples/TP/Basics.hs --- a/Documentation/SBV/Examples/TP/Basics.hs +++ b/Documentation/SBV/Examples/TP/Basics.hs @@ -112,20 +112,18 @@ -- | We cannot push a universal through a disjunction. We have: -- -- >>> forallDisjunctionNot @Integer (uninterpret "p") (uninterpret "q") `catch` (\(_ :: SomeException) -> pure ()) --- Lemma: forallConjunctionNot --- *** Failed to prove forallConjunctionNot. +-- Lemma: forallDisjunctionNot +-- *** Failed to prove forallDisjunctionNot. -- Falsifiable. Counter-example: -- p :: Integer -> Bool --- p 4 = True --- p 3 = False --- p _ = True +-- p 3 = True +-- p _ = False -- -- q :: Integer -> Bool --- q 4 = False --- q 3 = True +-- q 3 = False -- q _ = True -- --- Note how @p@ and @q@ differ in their treatment of the inputs 3 and 4, but agree everywhere else. So, for each +-- Note how @p@ and @q@ differ in their treatment of the input 3, but agree everywhere else. So, for each -- input, at least one of @p@ or @q@ is @True@, making the disjunction @True@ for all inputs. But the predicates -- @p@ and @q@ are not universally true themselves, constituting a counter-example. forallDisjunctionNot :: forall a. SymVal a => (SBV a -> SBool) -> (SBV a -> SBool) -> IO () @@ -133,7 +131,7 @@ let qb = quantifiedBool -- This won't prove! - _won'tGoThrough <- lemma "forallConjunctionNot" + _won'tGoThrough <- lemma "forallDisjunctionNot" ( (qb (\(Forall x) -> p x) .|| qb (\(Forall x) -> q x)) .<=> ------------------------------------------------------- qb (\(Forall x) -> p x .|| q x) @@ -368,7 +366,7 @@ -- Lemma: badRevLen -- *** Failed to prove badRevLen. -- Falsifiable. Counter-example: --- xs = [20,20,20] :: [Integer] +-- xs = [4,11,14] :: [Integer] badRevLen :: IO () badRevLen = runTP $ void $ lemma "badRevLen" @@ -376,7 +374,7 @@ [] -- | 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, +-- Below, we do a variant of the 'Documentation.SBV.Examples.TP.Lists.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: -- @@ -384,7 +382,7 @@ -- Lemma: badLengthProof -- *** Failed to prove badLengthProof. -- Falsifiable. Counter-example: --- xs = [13,16,19,24,34,42] :: [Integer] +-- xs = [11,13,16,18,21,42] :: [Integer] -- imp = 42 :: Integer -- spec = 6 :: Integer badLengthProof :: IO () diff --git a/Documentation/SBV/Examples/TP/ConstFold.hs b/Documentation/SBV/Examples/TP/ConstFold.hs --- a/Documentation/SBV/Examples/TP/ConstFold.hs +++ b/Documentation/SBV/Examples/TP/ConstFold.hs @@ -344,6 +344,7 @@ ?? "cons" ?? pfx .== h .: t =: SL.lookup k (h .: (t ++ b1 .: b2 .: env)) + ?? lkC `at` (Inst @"k" k, Inst @"b" h, Inst @"rest" (t ++ b1 .: b2 .: env)) =: ite (k .== hk) hv (SL.lookup k (t ++ b1 .: b2 .: env)) ?? ih `at` (Inst @"pfx" t, Inst @"k" k, Inst @"b1" b1, Inst @"b2" b2, Inst @"env" env) =: ite (k .== hk) hv (SL.lookup k (t ++ b2 .: b1 .: env)) diff --git a/Documentation/SBV/Examples/TP/Huffman.hs b/Documentation/SBV/Examples/TP/Huffman.hs new file mode 100644 --- /dev/null +++ b/Documentation/SBV/Examples/TP/Huffman.hs @@ -0,0 +1,1737 @@ +----------------------------------------------------------------------------- +-- | +-- Module : Documentation.SBV.Examples.TP.Huffman +-- Copyright : (c) Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Optimality of Huffman coding for positive integer frequencies. 'huffman' +-- takes a nonempty, sorted frequency queue and constructs a full binary code +-- tree. 'correctness' proves that it preserves every frequency and has no +-- greater weighted path length than any other full binary tree with the same +-- frequencies. There is no bound on the queue length or tree size. +-- +-- Trees carry weights rather than character labels: the cost depends only on +-- weights and depths, so repeated frequencies are tracked by multiplicities. +-- Symbols with equal frequencies can be assigned to the corresponding leaves +-- in any order. A singleton alphabet receives a zero-length code. +-- +-- The proof follows the greedy argument. 'greedyChoice' places the two minimum +-- weights at sibling positions without increasing cost. 'contraction' replaces +-- them by their sum. Strong induction on the queue length compares the recursive +-- Huffman tree with this contracted competitor. All recursive definitions have +-- checked termination measures; the proof introduces no axioms. +----------------------------------------------------------------------------- + +{-# LANGUAGE CPP #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedLists #-} +{-# LANGUAGE QuasiQuotes #-} +{-# LANGUAGE TemplateHaskell #-} +{-# LANGUAGE TypeAbstractions #-} +{-# LANGUAGE TypeApplications #-} + +{-# OPTIONS_GHC -Wall -Werror #-} + +module Documentation.SBV.Examples.TP.Huffman where + +import Data.SBV +import Data.SBV.TP + +import qualified Data.SBV.List as L + +#ifdef DOCTEST +-- $setup +-- >>> import Data.SBV +-- >>> import Data.SBV.TP +#endif + +-- * Trees and weighted path length + +-- | A full binary code tree. Leaves carry integer frequencies; internal +-- nodes represent a choice of the next bit. Optimality uses positive weights. +data Tree = Leaf Integer | Fork Tree Tree + deriving (Eq, Show) + +-- | A tree with one hole. Filling the hole selects an arbitrary subtree, +-- retaining both the siblings along its path and their left/right positions. +data Context = Hole | GoLeft Context Tree | GoRight Tree Context + deriving (Eq, Show) + +-- | A selected sibling pair, together with the context surrounding its fork. +data SiblingPair = SiblingPair Context Integer Integer + deriving (Eq, Show) + +-- | Symbolic trees and contexts, with their structural induction principles. +mkSymbolic [''Tree, ''Context, ''SiblingPair] + +-- | A deliberately unbalanced tree, with two occurrences of the minimum +-- weight. Moving them together illustrates why multiplicities matter. +-- +-- >>> unliteral exampleTree +-- Just (Fork (Leaf 1) (Fork (Leaf 5) (Fork (Leaf 1) (Leaf 3)))) +exampleTree :: STree +exampleTree = literal $ Fork (Leaf 1) (Fork (Leaf 5) (Fork (Leaf 1) (Leaf 3))) + +-- | Sum of the leaf weights. +-- +-- >>> weight exampleTree +-- 10 :: SInteger +weight :: STree -> SInteger +weight = smtFunction "weight" $ \t -> [sCase| t of + Leaf w -> w + Fork l r -> weight l + weight r + |] + +-- | Weighted external path length. Each branch adds one bit to every code +-- below it; this recurrence avoids explicitly multiplying weights by depths. +-- +-- >>> cost exampleTree +-- 23 :: SInteger +cost :: STree -> SInteger +cost = smtFunction "cost" $ \t -> [sCase| t of + Leaf _ -> 0 + Fork l r -> cost l + cost r + weight l + weight r + |] + +-- | Number of leaves carrying a particular weight. Comparing this for every +-- weight expresses multiset equality, including repeated frequencies. +-- +-- >>> count 1 exampleTree +-- 2 :: SInteger +count :: SInteger -> STree -> SInteger +count = smtFunction "count" $ \w t -> [sCase| t of + Leaf v -> ite (w .== v) 1 0 + Fork l r -> count w l + count w r + |] + +-- * Tree contexts and contraction + +-- | Replace the hole with a tree. +-- +-- >>> unliteral $ plug (literal (GoRight (Leaf 4) Hole)) (sLeaf 2) +-- Just (Fork (Leaf 4) (Leaf 2)) +plug :: SContext -> STree -> STree +plug = smtFunction "plug" $ \c t -> [sCase| c of + Hole -> t + GoLeft k r -> sFork (plug k t) r + GoRight l k -> sFork l (plug k t) + |] + +-- | Depth of the hole, measured from the root. +-- +-- >>> depth $ literal $ GoRight (Leaf 4) Hole +-- 1 :: SInteger +depth :: SContext -> SInteger +depth = smtFunction "depth" $ \c -> [sCase| c of + Hole -> 0 + GoLeft k _ -> 1 + depth k + GoRight _ k -> 1 + depth k + |] + +-- | Total weight outside the hole. +-- +-- >>> outsideWeight $ pairContext $ deepestPair exampleTree +-- 6 :: SInteger +outsideWeight :: SContext -> SInteger +outsideWeight = smtFunction "outsideWeight" $ \c -> [sCase| c of + Hole -> 0 + GoLeft k r -> outsideWeight k + weight r + GoRight l k -> weight l + outsideWeight k + |] + +-- | Cost contributed by the context when the hole is a zero-weight leaf. +-- +-- >>> outsideCost $ pairContext $ deepestPair exampleTree +-- 11 :: SInteger +outsideCost :: SContext -> SInteger +outsideCost = smtFunction "outsideCost" $ \c -> [sCase| c of + Hole -> 0 + GoLeft k r -> outsideCost k + cost r + outsideWeight k + weight r + GoRight l k -> cost l + outsideCost k + weight l + outsideWeight k + |] + +-- | Multiplicity of a weight outside the hole. +-- +-- >>> outsideCount 1 $ pairContext $ deepestPair exampleTree +-- 1 :: SInteger +outsideCount :: SInteger -> SContext -> SInteger +outsideCount = smtFunction "outsideCount" $ \w c -> [sCase| c of + Hole -> 0 + GoLeft k r -> outsideCount w k + count w r + GoRight l k -> count w l + outsideCount w k + |] + +-- | Filling the hole adds exactly the inserted tree's weight. +-- +-- >>> runTP weightPlug +-- Lemma: weightPlug Q.E.D. +-- Functions proven terminating: outsideWeight, plug, weight +-- [Proven] weightPlug :: Ɐc ∷ Context → Ɐt ∷ Tree → Bool +weightPlug :: TP (Proof (Forall "c" Context -> Forall "t" Tree -> SBool)) +weightPlug = inductiveLemma "weightPlug" (\(Forall c) (Forall t) -> weight (plug c t) .== outsideWeight c + weight t) [] + +-- | Filling the hole preserves the multiplicities outside it. +-- +-- >>> runTP countPlug +-- Lemma: countPlug Q.E.D. +-- Functions proven terminating: count, outsideCount, plug +-- [Proven] countPlug :: Ɐc ∷ Context → Ɐt ∷ Tree → Ɐw ∷ Integer → Bool +countPlug :: TP (Proof (Forall "c" Context -> Forall "t" Tree -> Forall "w" Integer -> SBool)) +countPlug = inductiveLemma "countPlug" (\(Forall c) (Forall t) (Forall w) -> count w (plug c t) .== outsideCount w c + count w t) [] + +-- | The inserted tree keeps its internal cost; every leaf also acquires +-- 'depth' additional bits from the surrounding context. +-- +-- >>> runTP costPlug +-- Lemma: weightPlug Q.E.D. +-- Lemma: depthNonNegative Q.E.D. +-- Inductive lemma (strong): costPlug +-- Step: Measure is non-negative Q.E.D. +-- Step: 1 (3 way case split) +-- Step: 1.1 Q.E.D. +-- Step: 1.2.1 Q.E.D. +-- Step: 1.2.2 Q.E.D. +-- Step: 1.2.3 Q.E.D. +-- Step: 1.2.4 Q.E.D. +-- Step: 1.2.5 Q.E.D. +-- Step: 1.3.1 Q.E.D. +-- Step: 1.3.2 Q.E.D. +-- Step: 1.3.3 Q.E.D. +-- Step: 1.3.4 Q.E.D. +-- Step: 1.3.5 Q.E.D. +-- Step: 1.Completeness Q.E.D. +-- Result: Q.E.D. +-- Functions proven terminating: cost, depth, outsideCost, outsideWeight, plug, weight +-- [Proven] costPlug :: Ɐc ∷ Context → Ɐt ∷ Tree → Bool +costPlug :: TP (Proof (Forall "c" Context -> Forall "t" Tree -> SBool)) +costPlug = do + wp <- recall weightPlug + dp <- recall depthNonNegative + sInduct "costPlug" + (\(Forall c) (Forall t) -> cost (plug c t) .== outsideCost c + cost t + depth c * weight t) + (\c _ -> depth c, [proofOf dp]) $ \ih c t -> + [] |- cost (plug c t) + =: [pCase| c of + Hole -> cost t =: qed + GoLeft k r -> cost (plug (sGoLeft k r) t) + =: cost (plug k t) + cost r + weight (plug k t) + weight r + ?? ih `at` (Inst @"c" k, Inst @"t" t) + =: outsideCost k + cost t + depth k * weight t + cost r + weight (plug k t) + weight r + ?? wp `at` (Inst @"c" k, Inst @"t" t) + =: outsideCost k + cost t + depth k * weight t + cost r + outsideWeight k + weight t + weight r + =: outsideCost (sGoLeft k r) + cost t + depth (sGoLeft k r) * weight t + =: qed + GoRight l k -> cost (plug (sGoRight l k) t) + =: cost l + cost (plug k t) + weight l + weight (plug k t) + ?? ih `at` (Inst @"c" k, Inst @"t" t) + =: cost l + outsideCost k + cost t + depth k * weight t + weight l + weight (plug k t) + ?? wp `at` (Inst @"c" k, Inst @"t" t) + =: cost l + outsideCost k + cost t + depth k * weight t + weight l + outsideWeight k + weight t + =: outsideCost (sGoRight l k) + cost t + depth (sGoRight l k) * weight t + =: qed + |] + +-- | Context depth is a nonnegative induction measure. +-- +-- >>> runTP depthNonNegative +-- Lemma: depthNonNegative Q.E.D. +-- Functions proven terminating: depth +-- [Proven] depthNonNegative :: Ɐc ∷ Context → Bool +depthNonNegative :: TP (Proof (Forall "c" Context -> SBool)) +depthNonNegative = inductiveLemma "depthNonNegative" (\(Forall c) -> depth c .>= 0) [] + +-- | Contracting sibling leaves of weights @a@ and @b@ to a single leaf of +-- weight @a+b@ decreases the total cost by exactly @a+b@, at any depth. +-- +-- >>> runTP contraction +-- Lemma: costPlug Q.E.D. +-- Lemma: contraction +-- Step: 1 Q.E.D. +-- Step: 2 Q.E.D. +-- Result: Q.E.D. +-- Functions proven terminating: cost, depth, outsideCost, outsideWeight, plug, weight +-- [Proven] contraction :: Ɐc ∷ Context → Ɐa ∷ Integer → Ɐb ∷ Integer → Bool +contraction :: TP (Proof (Forall "c" Context -> Forall "a" Integer -> Forall "b" Integer -> SBool)) +contraction = do + cp <- recall costPlug + calc "contraction" + (\(Forall c) (Forall a) (Forall b) -> cost (plug c (sFork (sLeaf a) (sLeaf b))) .== cost (plug c (sLeaf (a+b))) + a+b) $ \c a b -> + [] |- cost (plug c (sFork (sLeaf a) (sLeaf b))) + ?? cp `at` (Inst @"c" c, Inst @"t" (sFork (sLeaf a) (sLeaf b))) + =: outsideCost c + a+b + depth c * (a+b) + ?? cp `at` (Inst @"c" c, Inst @"t" (sLeaf (a+b))) + =: cost (plug c (sLeaf (a+b))) + a+b + =: qed + +-- * Finding deepest siblings + +-- | Maximum leaf depth. A tree consisting of one leaf has height zero. +-- +-- >>> height exampleTree +-- 3 :: SInteger +height :: STree -> SInteger +height = smtFunction "height" $ \t -> [sCase| t of + Leaf _ -> 0 + Fork l r -> 1 + smax (height l) (height r) + |] + +-- | Select a deepest sibling pair, preferring the left subtree on ties. +-- The singleton case is a placeholder; 'deepestPairCorrect' requires a fork. +-- +-- >>> unliteral $ deepestPair exampleTree +-- Just (SiblingPair (GoRight (Leaf 1) (GoRight (Leaf 5) Hole)) 1 3) +deepestPair :: STree -> SSiblingPair +deepestPair = smtFunction "deepestPair" $ \t -> [sCase| t of + Leaf w -> sSiblingPair sHole w w + Fork (Leaf a) (Leaf b) -> sSiblingPair sHole a b + Fork l r | height l .>= height r -> case deepestPair l of + SiblingPair c a b -> sSiblingPair (sGoLeft c r) a b + | True -> case deepestPair r of + SiblingPair c a b -> sSiblingPair (sGoRight l c) a b + |] + +-- | Reconstruct a tree from a selected sibling pair and its context. +-- +-- >>> rebuildPair (deepestPair exampleTree) .== exampleTree +-- True +rebuildPair :: SSiblingPair -> STree +rebuildPair p = [sCase| p of + SiblingPair c a b -> plug c (sFork (sLeaf a) (sLeaf b)) + |] + +-- | Depth of either selected sibling leaf. +-- +-- >>> siblingDepth $ deepestPair exampleTree +-- 3 :: SInteger +siblingDepth :: SSiblingPair -> SInteger +siblingDepth p = [sCase| p of + SiblingPair c _ _ -> depth c + 1 + |] + +-- | Every tree has a nonnegative height. +-- +-- >>> runTP heightNonNegative +-- Lemma: heightNonNegative Q.E.D. +-- Functions proven terminating: height +-- [Proven] heightNonNegative :: Ɐt ∷ Tree → Bool +heightNonNegative :: TP (Proof (Forall "t" Tree -> SBool)) +heightNonNegative = inductiveLemma "heightNonNegative" (\(Forall t) -> height t .>= 0) [] + +-- | Height zero characterizes leaves; every fork has positive height. +-- +-- >>> runTP heightZero +-- Lemma: heightNonNegative Q.E.D. +-- Lemma: heightZero Q.E.D. +-- Functions proven terminating: height +-- [Proven] heightZero :: Ɐt ∷ Tree → Bool +heightZero :: TP (Proof (Forall "t" Tree -> SBool)) +heightZero = do + hn <- recall heightNonNegative + lemma "heightZero" (\(Forall t) -> (height t .== 0) .== isLeaf t) [proofOf hn] + +-- | Selecting deepest siblings preserves the entire original tree, and both +-- selected leaves are at its maximum depth. Thus the selection is structural, +-- not an assumption about an already suitably arranged tree. +-- +-- >>> runTP deepestPairCorrect +-- Lemma: heightNonNegative Q.E.D. +-- Lemma: heightZero Q.E.D. +-- Lemma: deepestPairCorrect Q.E.D. +-- Functions proven terminating: deepestPair, depth, height, plug +-- [Proven] deepestPairCorrect :: Ɐt ∷ Tree → Bool +deepestPairCorrect :: TP (Proof (Forall "t" Tree -> SBool)) +deepestPairCorrect = do + hn <- recall heightNonNegative + hz <- recall heightZero + inductiveLemma "deepestPairCorrect" + (\(Forall t) -> isFork t .=> rebuildPair (deepestPair t) .== t .&& siblingDepth (deepestPair t) .== height t) + [proofOf hn, proofOf hz] + +-- * Locating and replacing leaves + +-- | Replace the first occurrence of a leaf weight, searching left before +-- right. If the weight is absent, the tree is unchanged. +-- +-- >>> unliteral $ replace 1 2 exampleTree +-- Just (Fork (Leaf 2) (Fork (Leaf 5) (Fork (Leaf 1) (Leaf 3)))) +-- +-- >>> replace 99 2 exampleTree .== exampleTree +-- True +replace :: SInteger -> SInteger -> STree -> STree +replace = smtFunction "replace" $ \old new t -> [sCase| t of + Leaf w -> sLeaf (ite (w .== old) new w) + Fork l r | count old l .> 0 -> sFork (replace old new l) r + | True -> sFork l (replace old new r) + |] + +-- | Depth of the first leaf with the given weight, using the same traversal +-- as 'replace'. When absent this returns the rightmost leaf's depth. +-- +-- >>> leafDepth 1 exampleTree +-- 1 :: SInteger +leafDepth :: SInteger -> STree -> SInteger +leafDepth = smtFunction "leafDepth" $ \w t -> [sCase| t of + Leaf _ -> 0 + Fork l r -> 1 + ite (count w l .> 0) (leafDepth w l) (leafDepth w r) + |] + +-- | Leaf multiplicities are nonnegative. +-- +-- >>> runTP countNonNegative +-- Lemma: countNonNegative Q.E.D. +-- Functions proven terminating: count +-- [Proven] countNonNegative :: Ɐt ∷ Tree → Ɐw ∷ Integer → Bool +countNonNegative :: TP (Proof (Forall "t" Tree -> Forall "w" Integer -> SBool)) +countNonNegative = inductiveLemma "countNonNegative" (\(Forall t) (Forall w) -> count w t .>= 0) [] + +-- | Replacing a weight preserves the shape and hence the height of the tree. +-- +-- >>> runTP replaceHeight +-- Lemma: replaceHeight Q.E.D. +-- Functions proven terminating: count, height, replace +-- [Proven] replaceHeight :: Ɐt ∷ Tree → Ɐold ∷ Integer → Ɐnew ∷ Integer → Bool +replaceHeight :: TP (Proof (Forall "t" Tree -> Forall "old" Integer -> Forall "new" Integer -> SBool)) +replaceHeight = inductiveLemma "replaceHeight" (\(Forall t) (Forall old) (Forall new) -> height (replace old new t) .== height t) [] + +-- | The replacement changes exactly one occurrence, even when weights tie. +-- +-- >>> runTP replaceCount +-- Lemma: countNonNegative Q.E.D. +-- Lemma: replaceCount Q.E.D. +-- Functions proven terminating: count, replace +-- [Proven] replaceCount :: Ɐt ∷ Tree → Ɐold ∷ Integer → Ɐnew ∷ Integer → Ɐw ∷ Integer → Bool +replaceCount :: TP (Proof (Forall "t" Tree -> Forall "old" Integer -> Forall "new" Integer -> Forall "w" Integer -> SBool)) +replaceCount = do + cn <- recall countNonNegative + inductiveLemma "replaceCount" + (\(Forall t) (Forall old) (Forall new) (Forall w) -> count old t .> 0 .=> + count w (replace old new t) .== count w t + ite (w .== new) 1 0 - ite (w .== old) 1 0) + [proofOf cn] + +-- | Exact cost of replacing a selected leaf, at its actual depth. +-- +-- >>> runTP replaceCost +-- Lemma: locateCorrect Q.E.D. +-- Lemma: costPlug Q.E.D. +-- Lemma: replaceCost +-- Step: 1 Q.E.D. +-- Step: 2 Q.E.D. +-- Step: 3 Q.E.D. +-- Result: Q.E.D. +-- Functions proven terminating: cost, count, depth, leafDepth, locate, outsideCost, outsideWeight, plug, replace, weight +-- [Proven] replaceCost :: Ɐt ∷ Tree → Ɐold ∷ Integer → Ɐnew ∷ Integer → Bool +replaceCost :: TP (Proof (Forall "t" Tree -> Forall "old" Integer -> Forall "new" Integer -> SBool)) +replaceCost = do + lc <- recall locateCorrect + cp <- recall costPlug + calc "replaceCost" + (\(Forall t) (Forall old) (Forall new) -> count old t .> 0 .=> + cost (replace old new t) .== cost t + (new-old) * leafDepth old t) $ \t old new -> + let c = locate old t + in [count old t .> 0] + |- cost (replace old new t) + ?? lc `at` (Inst @"t" t, Inst @"w" old, Inst @"new" new) + =: cost (plug c (sLeaf new)) + ?? cp `at` (Inst @"c" c, Inst @"t" (sLeaf new)) + =: outsideCost c + depth c * new + ?? cp `at` (Inst @"c" c, Inst @"t" (sLeaf old)) + ?? lc `at` (Inst @"t" t, Inst @"w" old, Inst @"new" new) + =: cost t + (new-old) * leafDepth old t + =: qed + +-- | Locate the first occurrence of a weight as a context. The result is +-- meaningful when the weight occurs in the tree. +-- +-- >>> unliteral $ locate 5 exampleTree +-- Just (GoRight (Leaf 1) (GoLeft Hole (Fork (Leaf 1) (Leaf 3)))) +locate :: SInteger -> STree -> SContext +locate = smtFunction "locate" $ \w t -> [sCase| t of + Leaf _ -> sHole + Fork l r | count w l .> 0 -> sGoLeft (locate w l) r + | True -> sGoRight l (locate w r) + |] + +-- | The selected context reconstructs the tree, implements replacement, +-- and records the same leaf depth as the direct traversal. +-- +-- >>> runTP locateCorrect +-- Lemma: countNonNegative Q.E.D. +-- Lemma: locateCorrect Q.E.D. +-- Functions proven terminating: count, depth, leafDepth, locate, plug, replace +-- [Proven] locateCorrect :: Ɐt ∷ Tree → Ɐw ∷ Integer → Ɐnew ∷ Integer → Bool +locateCorrect :: TP (Proof (Forall "t" Tree -> Forall "w" Integer -> Forall "new" Integer -> SBool)) +locateCorrect = do + cn <- recall countNonNegative + inductiveLemma "locateCorrect" + (\(Forall t) (Forall w) (Forall new) -> count w t .> 0 .=> + plug (locate w t) (sLeaf w) .== t + .&& plug (locate w t) (sLeaf new) .== replace w new t + .&& depth (locate w t) .== leafDepth w t) + [proofOf cn] + +-- | The selected leaf is no deeper than the deepest leaf. +-- +-- >>> runTP leafDepthBound +-- Lemma: leafDepthBound Q.E.D. +-- Functions proven terminating: count, height, leafDepth +-- [Proven] leafDepthBound :: Ɐt ∷ Tree → Ɐw ∷ Integer → Bool +leafDepthBound :: TP (Proof (Forall "t" Tree -> Forall "w" Integer -> SBool)) +leafDepthBound = inductiveLemma "leafDepthBound" (\(Forall t) (Forall w) -> leafDepth w t .<= height t) [] + +-- * Replacing leaves outside a context + +-- | Replace the first occurrence outside the hole, leaving the hole itself +-- untouched. This lets us install a minimum weight in a chosen sibling pair +-- without disturbing the other member of that pair. +-- +-- >>> unliteral $ replaceOutside 1 3 $ pairContext $ deepestPair exampleTree +-- Just (GoRight (Leaf 3) (GoRight (Leaf 5) Hole)) +replaceOutside :: SInteger -> SInteger -> SContext -> SContext +replaceOutside = smtFunction "replaceOutside" $ \old new c -> + [sCase| c of + Hole -> sHole + + GoLeft k r | outsideCount old k .> 0 -> sGoLeft (replaceOutside old new k) r + | True -> sGoLeft k (replace old new r) + + GoRight l k | count old l .> 0 -> sGoRight (replace old new l) k + | True -> sGoRight l (replaceOutside old new k) + |] + +-- | Replacing outside leaves does not change the hole's depth. +-- +-- >>> runTP replaceOutsideDepth +-- Lemma: replaceOutsideDepth Q.E.D. +-- Functions proven terminating: count, depth, outsideCount, replace, replaceOutside +-- [Proven] replaceOutsideDepth :: Ɐc ∷ Context → Ɐold ∷ Integer → Ɐnew ∷ Integer → Bool +replaceOutsideDepth :: TP (Proof (Forall "c" Context -> Forall "old" Integer -> Forall "new" Integer -> SBool)) +replaceOutsideDepth = inductiveLemma "replaceOutsideDepth" (\(Forall c) (Forall old) (Forall new) -> depth (replaceOutside old new c) .== depth c) [] + +-- | A zero-weight leaf marks the hole. Replacing a nonzero weight in that +-- tree is exactly replacement outside the context's hole. +-- +-- >>> runTP replaceOutsideEmbedding +-- Lemma: countPlug Q.E.D. +-- Lemma: replaceOutsideEmbedding Q.E.D. +-- Functions proven terminating: count, outsideCount, plug, replace, replaceOutside +-- [Proven] replaceOutsideEmbedding :: Ɐc ∷ Context → Ɐold ∷ Integer → Ɐnew ∷ Integer → Bool +replaceOutsideEmbedding :: TP (Proof (Forall "c" Context -> Forall "old" Integer -> Forall "new" Integer -> SBool)) +replaceOutsideEmbedding = do + cp <- recall countPlug + + inductiveLemma "replaceOutsideEmbedding" + (\(Forall c) (Forall old) (Forall new) -> old ./= 0 .=> + plug (replaceOutside old new c) (sLeaf 0) .== replace old new (plug c (sLeaf 0))) + [proofOf cp] + +-- | Multiplicity change outside the hole, derived from replacement in the +-- tree marked with a zero-weight leaf. +-- +-- >>> runTP replaceOutsideCount +-- Lemma: replaceOutsideEmbedding Q.E.D. +-- Lemma: replaceCount Q.E.D. +-- Lemma: countPlug Q.E.D. [Cached] +-- Lemma: replaceOutsideCount +-- Step: 1 Q.E.D. +-- Step: 2 Q.E.D. +-- Step: 3 Q.E.D. +-- Step: 4 Q.E.D. +-- Result: Q.E.D. +-- Functions proven terminating: count, outsideCount, plug, replace, replaceOutside +-- [Proven] replaceOutsideCount :: Ɐc ∷ Context → Ɐold ∷ Integer → Ɐnew ∷ Integer → Ɐw ∷ Integer → Bool +replaceOutsideCount :: TP (Proof (Forall "c" Context -> Forall "old" Integer -> Forall "new" Integer -> Forall "w" Integer -> SBool)) +replaceOutsideCount = do + re <- recall replaceOutsideEmbedding + rc <- recall replaceCount + cp <- recall countPlug + + calc "replaceOutsideCount" + (\(Forall c) (Forall old) (Forall new) (Forall w) -> old ./= 0 .&& outsideCount old c .> 0 .=> + outsideCount w (replaceOutside old new c) .== outsideCount w c + ite (w .== new) 1 0 - ite (w .== old) 1 0) $ \c old new w -> + let changed = replaceOutside old new c + marked = plug c (sLeaf 0) + in [old ./= 0, outsideCount old c .> 0] + |- outsideCount w changed + ?? cp `at` (Inst @"c" changed, Inst @"t" (sLeaf 0), Inst @"w" w) + =: count w (plug changed (sLeaf 0)) - ite (w .== 0) 1 0 + ?? re `at` (Inst @"c" c, Inst @"old" old, Inst @"new" new) + =: count w (replace old new marked) - ite (w .== 0) 1 0 + ?? cp `at` (Inst @"c" c, Inst @"t" (sLeaf 0), Inst @"w" old) + ?? rc `at` (Inst @"t" marked, Inst @"old" old, Inst @"new" new, Inst @"w" w) + =: count w marked + ite (w .== new) 1 0 - ite (w .== old) 1 0 - ite (w .== 0) 1 0 + ?? cp `at` (Inst @"c" c, Inst @"t" (sLeaf 0), Inst @"w" w) + =: outsideCount w c + ite (w .== new) 1 0 - ite (w .== old) 1 0 + =: qed + +-- | Replacing weights outside the hole preserves the marked tree's height. +-- +-- >>> runTP replaceOutsideHeight +-- Lemma: replaceOutsideEmbedding Q.E.D. +-- Lemma: replaceHeight Q.E.D. +-- Lemma: replaceOutsideHeight +-- Step: 1 Q.E.D. +-- Step: 2 Q.E.D. +-- Result: Q.E.D. +-- Functions proven terminating: count, height, outsideCount, plug, replace, replaceOutside +-- [Proven] replaceOutsideHeight :: Ɐc ∷ Context → Ɐold ∷ Integer → Ɐnew ∷ Integer → Bool +replaceOutsideHeight :: TP (Proof (Forall "c" Context -> Forall "old" Integer -> Forall "new" Integer -> SBool)) +replaceOutsideHeight = do + re <- recall replaceOutsideEmbedding + rh <- recall replaceHeight + + calc "replaceOutsideHeight" + (\(Forall c) (Forall old) (Forall new) -> old ./= 0 .=> + height (plug (replaceOutside old new c) (sLeaf 0)) .== height (plug c (sLeaf 0))) $ \c old new -> + [old ./= 0] |- height (plug (replaceOutside old new c) (sLeaf 0)) + ?? re `at` (Inst @"c" c, Inst @"old" old, Inst @"new" new) + =: height (replace old new (plug c (sLeaf 0))) + ?? rh `at` (Inst @"t" (plug c (sLeaf 0)), Inst @"old" old, Inst @"new" new) + =: height (plug c (sLeaf 0)) + =: qed + +-- | Exact change to the outside cost when one nonzero weight is replaced. +-- +-- >>> runTP replaceOutsideCost +-- Lemma: replaceOutsideEmbedding Q.E.D. +-- Lemma: replaceCost Q.E.D. +-- Lemma: costPlug Q.E.D. [Cached] +-- Lemma: countPlug Q.E.D. [Cached] +-- Lemma: replaceOutsideCost +-- Step: 1 Q.E.D. +-- Step: 2 Q.E.D. +-- Step: 3 Q.E.D. +-- Step: 4 Q.E.D. +-- Result: Q.E.D. +-- Functions proven terminating: +-- cost, count, depth, leafDepth, locate, outsideCost, outsideCount, outsideWeight, plug, +-- replace, replaceOutside, weight +-- [Proven] replaceOutsideCost :: Ɐc ∷ Context → Ɐold ∷ Integer → Ɐnew ∷ Integer → Bool +replaceOutsideCost :: TP (Proof (Forall "c" Context -> Forall "old" Integer -> Forall "new" Integer -> SBool)) +replaceOutsideCost = do + re <- recall replaceOutsideEmbedding + rc <- recall replaceCost + cp <- recall costPlug + cn <- recall countPlug + + calc "replaceOutsideCost" + (\(Forall c) (Forall old) (Forall new) -> old ./= 0 .&& outsideCount old c .> 0 .=> + outsideCost (replaceOutside old new c) .== outsideCost c + (new-old) * leafDepth old (plug c (sLeaf 0))) $ \c old new -> + let changed = replaceOutside old new c + marked = plug c (sLeaf 0) + in [old ./= 0, outsideCount old c .> 0] + |- outsideCost changed + ?? cp `at` (Inst @"c" changed, Inst @"t" (sLeaf 0)) + =: cost (plug changed (sLeaf 0)) + ?? re `at` (Inst @"c" c, Inst @"old" old, Inst @"new" new) + =: cost (replace old new marked) + ?? cn `at` (Inst @"c" c, Inst @"t" (sLeaf 0), Inst @"w" old) + ?? rc `at` (Inst @"t" marked, Inst @"old" old, Inst @"new" new) + =: cost marked + (new-old) * leafDepth old marked + ?? cp `at` (Inst @"c" c, Inst @"t" (sLeaf 0)) + =: outsideCost c + (new-old) * leafDepth old marked + =: qed + +-- * Moving minimum weights into sibling positions + +-- | A smaller inserted tree cannot increase the height of its context. +-- +-- >>> runTP heightPlugMonotone +-- Lemma: depthNonNegative Q.E.D. +-- Inductive lemma (strong): heightPlugMonotone +-- Step: Measure is non-negative Q.E.D. +-- Step: 1 (3 way case split) +-- Step: 1.1.1 Q.E.D. +-- Step: 1.1.2 Q.E.D. +-- Step: 1.2.1 Q.E.D. +-- Step: 1.2.2 Q.E.D. +-- Step: 1.3.1 Q.E.D. +-- Step: 1.3.2 Q.E.D. +-- Step: 1.Completeness Q.E.D. +-- Result: Q.E.D. +-- Functions proven terminating: depth, height, plug +-- [Proven] heightPlugMonotone :: Ɐc ∷ Context → Ɐu ∷ Tree → Ɐv ∷ Tree → Bool +heightPlugMonotone :: TP (Proof (Forall "c" Context -> Forall "u" Tree -> Forall "v" Tree -> SBool)) +heightPlugMonotone = do + dn <- recall depthNonNegative + sInduct "heightPlugMonotone" + (\(Forall c) (Forall u) (Forall v) -> height u .<= height v .=> height (plug c u) .<= height (plug c v)) + (\c _ _ -> depth c, [proofOf dn]) $ \ih c u v -> + [height u .<= height v] |- height (plug c u) .<= height (plug c v) + =: [pCase| c of + Hole -> height u .<= height v =: sTrue =: qed + + GoLeft k r -> smax (height (plug k u)) (height r) .<= smax (height (plug k v)) (height r) + ?? ih `at` (Inst @"c" k, Inst @"u" u, Inst @"v" v) + =: sTrue + =: qed + + GoRight l k -> smax (height l) (height (plug k u)) .<= smax (height l) (height (plug k v)) + ?? ih `at` (Inst @"c" k, Inst @"u" u, Inst @"v" v) + =: sTrue + =: qed + |] + +-- | Children inserted at the hole would be at least as deep as every outside +-- leaf, allowing them to receive smaller weights without increasing cost. +deepest :: SContext -> SBool +deepest c = height (plug c (sLeaf 0)) .<= depth c + 1 + +-- | The context selected by 'deepestPair' satisfies the depth bound needed +-- when moving minimum weights into the selected sibling positions. +-- +-- >>> runTP deepestPairBound +-- Lemma: deepestPairCorrect Q.E.D. +-- Lemma: heightPlugMonotone Q.E.D. +-- Lemma: deepestPairBound +-- Step: 1 Q.E.D. +-- Result: Q.E.D. +-- Functions proven terminating: deepestPair, depth, height, plug +-- [Proven] deepestPairBound :: Ɐt ∷ Tree → Bool +deepestPairBound :: TP (Proof (Forall "t" Tree -> SBool)) +deepestPairBound = do + dp <- recall deepestPairCorrect + hm <- recall heightPlugMonotone + + calc "deepestPairBound" + (\(Forall t) -> isFork t .=> deepest (pairContext (deepestPair t))) $ \t -> + let p = deepestPair t + c = pairContext p + u = sLeaf 0 + v = sFork (sLeaf (firstWeight p)) (sLeaf (secondWeight p)) + in [isFork t] |- deepest c + ?? dp `at` Inst @"t" t + ?? hm `at` (Inst @"c" c, Inst @"u" u, Inst @"v" v) + =: sTrue + =: qed + +-- | Exact cost at a selected sibling pair. +-- +-- >>> runTP siblingCost +-- Lemma: costPlug Q.E.D. +-- Lemma: siblingCost Q.E.D. +-- Functions proven terminating: cost, depth, outsideCost, outsideWeight, plug, weight +-- [Proven] siblingCost :: Ɐc ∷ Context → Ɐx ∷ Integer → Ɐy ∷ Integer → Bool +siblingCost :: TP (Proof (Forall "c" Context -> Forall "x" Integer -> Forall "y" Integer -> SBool)) +siblingCost = do + cp <- recall costPlug + lemma "siblingCost" + (\(Forall c) (Forall x) (Forall y) -> + cost (plug c (sFork (sLeaf x) (sLeaf y))) .== outsideCost c + (depth c + 1) * (x+y)) + [proofOf cp] + +-- | Exchange an outside minimum with the left leaf of a deepest sibling +-- pair. The right leaf is untouched, so it can hold a previously placed +-- minimum even when the two smallest weights are equal. +-- +-- >>> runTP sinkCost +-- Lemma: replaceOutsideCost Q.E.D. +-- Lemma: replaceOutsideDepth Q.E.D. +-- Lemma: siblingCost Q.E.D. +-- Lemma: leafDepthBound Q.E.D. +-- Lemma: sinkCost +-- Step: 1 Q.E.D. +-- Step: 2 Q.E.D. +-- Step: 3 Q.E.D. +-- Result: Q.E.D. +-- Functions proven terminating: +-- cost, count, depth, height, leafDepth, locate, outsideCost, outsideCount, outsideWeight, +-- plug, replace, replaceOutside, weight +-- [Proven] sinkCost :: Ɐc ∷ Context → Ɐa ∷ Integer → Ɐx ∷ Integer → Ɐy ∷ Integer → Bool +sinkCost :: TP (Proof (Forall "c" Context -> Forall "a" Integer -> Forall "x" Integer -> Forall "y" Integer -> SBool)) +sinkCost = do + rc <- recall replaceOutsideCost + rd <- recall replaceOutsideDepth + sc <- recall siblingCost + lb <- recall leafDepthBound + + calc "sinkCost" + (\(Forall c) (Forall a) (Forall x) (Forall y) -> + a .> 0 .&& a .<= x .&& outsideCount a c .> 0 .&& deepest c .=> + cost (plug (replaceOutside a x c) (sFork (sLeaf a) (sLeaf y))) .<= + cost (plug c (sFork (sLeaf x) (sLeaf y)))) $ \c a x y -> + let changed = replaceOutside a x c + in [a .> 0, a .<= x, outsideCount a c .> 0, deepest c] |- cost (plug changed (sFork (sLeaf a) (sLeaf y))) .<= cost (plug c (sFork (sLeaf x) (sLeaf y))) + ?? sc `at` (Inst @"c" changed, Inst @"x" a, Inst @"y" y) + ?? sc `at` (Inst @"c" c, Inst @"x" x, Inst @"y" y) + ?? rd `at` (Inst @"c" c, Inst @"old" a, Inst @"new" x) + =: outsideCost changed + (depth c + 1) * (a+y) .<= outsideCost c + (depth c + 1) * (x+y) + ?? rc `at` (Inst @"c" c, Inst @"old" a, Inst @"new" x) + =: (x-a) * (leafDepth a (plug c (sLeaf 0)) - (depth c + 1)) .<= 0 + ?? lb `at` (Inst @"t" (plug c (sLeaf 0)), Inst @"w" a) + =: sTrue + =: qed + +-- | Place the smallest weight in the left sibling position, exchanging +-- within the pair if possible and otherwise looking outside it. +-- +-- >>> unliteral $ placeFirst 1 $ literal $ SiblingPair Hole 3 1 +-- Just (SiblingPair Hole 1 3) +placeFirst :: SInteger -> SSiblingPair -> SSiblingPair +placeFirst a p = [sCase| p of + SiblingPair c x y | a .== x -> p + | a .== y -> sSiblingPair c a x + | True -> sSiblingPair (replaceOutside a x c) a y + |] + +-- | Place the second smallest weight in the right sibling position. +-- Outside replacement protects the first slot, including when weights tie. +-- +-- >>> unliteral $ placeSecond 1 $ deepestPair exampleTree +-- Just (SiblingPair (GoRight (Leaf 3) (GoRight (Leaf 5) Hole)) 1 1) +placeSecond :: SInteger -> SSiblingPair -> SSiblingPair +placeSecond b p = [sCase| p of + SiblingPair c x y | b .== y -> p + | True -> sSiblingPair (replaceOutside b y c) x b + |] + +-- | Multiplicities outside a context's hole are nonnegative. +-- +-- >>> runTP outsideCountNonNegative +-- Lemma: countNonNegative Q.E.D. +-- Lemma: outsideCountNonNegative Q.E.D. +-- Functions proven terminating: count, outsideCount +-- [Proven] outsideCountNonNegative :: Ɐc ∷ Context → Ɐw ∷ Integer → Bool +outsideCountNonNegative :: TP (Proof (Forall "c" Context -> Forall "w" Integer -> SBool)) +outsideCountNonNegative = do + cn <- recall countNonNegative + + inductiveLemma "outsideCountNonNegative" (\(Forall c) (Forall w) -> outsideCount w c .>= 0) [proofOf cn] + +-- | The surrounding context of a selected pair. +pairContext :: SSiblingPair -> SContext +pairContext p = [sCase| p of SiblingPair c _ _ -> c |] + +-- | The weight at the first selected sibling position. +firstWeight :: SSiblingPair -> SInteger +firstWeight p = [sCase| p of SiblingPair _ x _ -> x |] + +-- | The weight at the second selected sibling position. +secondWeight :: SSiblingPair -> SInteger +secondWeight p = [sCase| p of SiblingPair _ _ y -> y |] + +-- | Swapping an outside occurrence into a deepest sibling slot preserves +-- multiplicities and the depth bound, while never increasing cost. +-- +-- >>> runTP sinkCorrect +-- Lemma: sinkCost Q.E.D. +-- Lemma: replaceOutsideCount Q.E.D. +-- Lemma: replaceOutsideDepth Q.E.D. [Cached] +-- Lemma: replaceOutsideHeight Q.E.D. +-- Lemma: countPlug Q.E.D. [Cached] +-- Lemma: sinkCorrect +-- Step: 1 Q.E.D. +-- Result: Q.E.D. +-- Functions proven terminating: +-- cost, count, depth, height, leafDepth, locate, outsideCost, outsideCount, outsideWeight, +-- plug, replace, replaceOutside, weight +-- [Proven] sinkCorrect :: Ɐc ∷ Context → Ɐa ∷ Integer → Ɐx ∷ Integer → Ɐy ∷ Integer → Ɐw ∷ Integer → Bool +sinkCorrect :: TP (Proof (Forall "c" Context -> Forall "a" Integer -> Forall "x" Integer + -> Forall "y" Integer -> Forall "w" Integer -> SBool)) +sinkCorrect = do + sc <- recall sinkCost + rc <- recall replaceOutsideCount + rd <- recall replaceOutsideDepth + rh <- recall replaceOutsideHeight + cp <- recall countPlug + + calc "sinkCorrect" + (\(Forall c) (Forall a) (Forall x) (Forall y) (Forall w) -> + a .> 0 .&& a .<= x .&& outsideCount a c .> 0 .&& deepest c .=> + let changed = replaceOutside a x c + before = plug c (sFork (sLeaf x) (sLeaf y)) + after = plug changed (sFork (sLeaf a) (sLeaf y)) + in count w after .== count w before .&& cost after .<= cost before .&& deepest changed) $ \c a x y w -> + let changed = replaceOutside a x c + before = plug c (sFork (sLeaf x) (sLeaf y)) + after = plug changed (sFork (sLeaf a) (sLeaf y)) + in [a .> 0, a .<= x, outsideCount a c .> 0, deepest c] |- count w after .== count w before .&& cost after .<= cost before .&& deepest changed + ?? sc `at` (Inst @"c" c, Inst @"a" a, Inst @"x" x, Inst @"y" y) + ?? rc `at` (Inst @"c" c, Inst @"old" a, Inst @"new" x, Inst @"w" w) + ?? rd `at` (Inst @"c" c, Inst @"old" a, Inst @"new" x) + ?? rh `at` (Inst @"c" c, Inst @"old" a, Inst @"new" x) + ?? cp `at` (Inst @"c" c, Inst @"t" (sFork (sLeaf x) (sLeaf y)), Inst @"w" w) + ?? cp `at` (Inst @"c" changed, Inst @"t" (sFork (sLeaf a) (sLeaf y)), Inst @"w" w) + =: sTrue + =: qed + +-- | Installing the first minimum preserves the tree's multiset, does not +-- increase cost, and leaves the selected slots deepest. +-- +-- >>> runTP placeFirstCorrect +-- Lemma: sinkCorrect Q.E.D. +-- Lemma: countPlug Q.E.D. [Cached] +-- Lemma: siblingCost Q.E.D. [Cached] +-- Lemma: placeFirstCorrect +-- Step: 1 Q.E.D. +-- Result: Q.E.D. +-- Functions proven terminating: +-- cost, count, depth, height, leafDepth, locate, outsideCost, outsideCount, outsideWeight, +-- plug, replace, replaceOutside, weight +-- [Proven] placeFirstCorrect :: Ɐc ∷ Context → Ɐa ∷ Integer → Ɐx ∷ Integer → Ɐy ∷ Integer → Ɐw ∷ Integer → Bool +placeFirstCorrect :: TP (Proof (Forall "c" Context -> Forall "a" Integer -> Forall "x" Integer + -> Forall "y" Integer -> Forall "w" Integer -> SBool)) +placeFirstCorrect = do + sc <- recall sinkCorrect + cp <- recall countPlug + cc <- recall siblingCost + + calc "placeFirstCorrect" + (\(Forall c) (Forall a) (Forall x) (Forall y) (Forall w) -> + let p = sSiblingPair c x y + q = placeFirst a p + in a .> 0 .&& a .<= x .&& a .<= y .&& count a (rebuildPair p) .> 0 .&& deepest c .=> + firstWeight q .== a .&& count w (rebuildPair q) .== count w (rebuildPair p) + .&& cost (rebuildPair q) .<= cost (rebuildPair p) .&& deepest (pairContext q)) $ \c a x y w -> + let p = sSiblingPair c x y + q = placeFirst a p + in [a .> 0, a .<= x, a .<= y, count a (rebuildPair p) .> 0, deepest c] |- firstWeight q .== a .&& count w (rebuildPair q) .== count w (rebuildPair p) + .&& cost (rebuildPair q) .<= cost (rebuildPair p) .&& deepest (pairContext q) + ?? cp `at` (Inst @"c" c, Inst @"t" (sFork (sLeaf x) (sLeaf y)), Inst @"w" a) + ?? sc `at` (Inst @"c" c, Inst @"a" a, Inst @"x" x, Inst @"y" y, Inst @"w" w) + ?? cp `at` (Inst @"c" c, Inst @"t" (sFork (sLeaf x) (sLeaf y)), Inst @"w" w) + ?? cp `at` (Inst @"c" c, Inst @"t" (sFork (sLeaf y) (sLeaf x)), Inst @"w" w) + ?? cc `at` (Inst @"c" c, Inst @"x" x, Inst @"y" y) + ?? cc `at` (Inst @"c" c, Inst @"x" y, Inst @"y" x) + =: sTrue + =: qed + +-- | Installing the second minimum preserves the first, including the case +-- of equal minima: the occurrence count requires a separate copy for it. +-- +-- >>> runTP placeSecondCorrect +-- Lemma: sinkCorrect Q.E.D. +-- Lemma: countPlug Q.E.D. [Cached] +-- Lemma: siblingCost Q.E.D. [Cached] +-- Lemma: placeSecondCorrect +-- Step: 1 Q.E.D. +-- Result: Q.E.D. +-- Functions proven terminating: +-- cost, count, depth, height, leafDepth, locate, outsideCost, outsideCount, outsideWeight, +-- plug, replace, replaceOutside, weight +-- [Proven] placeSecondCorrect :: Ɐc ∷ Context → Ɐa ∷ Integer → Ɐb ∷ Integer → Ɐy ∷ Integer → Ɐw ∷ Integer → Bool +placeSecondCorrect :: TP (Proof (Forall "c" Context -> Forall "a" Integer -> Forall "b" Integer + -> Forall "y" Integer -> Forall "w" Integer -> SBool)) +placeSecondCorrect = do + sc <- recall sinkCorrect + cp <- recall countPlug + cc <- recall siblingCost + + calc "placeSecondCorrect" + (\(Forall c) (Forall a) (Forall b) (Forall y) (Forall w) -> + let p = sSiblingPair c a y + q = placeSecond b p + in b .> 0 .&& b .<= y .&& count b (rebuildPair p) .>= 1 + ite (a .== b) 1 0 .&& deepest c .=> + firstWeight q .== a .&& secondWeight q .== b + .&& count w (rebuildPair q) .== count w (rebuildPair p) + .&& cost (rebuildPair q) .<= cost (rebuildPair p)) $ \c a b y w -> + let p = sSiblingPair c a y + q = placeSecond b p + changed = replaceOutside b y c + in [b .> 0, b .<= y, count b (rebuildPair p) .>= 1 + ite (a .== b) 1 0, deepest c] |- firstWeight q .== a .&& secondWeight q .== b + .&& count w (rebuildPair q) .== count w (rebuildPair p) + .&& cost (rebuildPair q) .<= cost (rebuildPair p) + ?? cp `at` (Inst @"c" c, Inst @"t" (sFork (sLeaf a) (sLeaf y)), Inst @"w" b) + ?? sc `at` (Inst @"c" c, Inst @"a" b, Inst @"x" y, Inst @"y" a, Inst @"w" w) + ?? cp `at` (Inst @"c" c, Inst @"t" (sFork (sLeaf a) (sLeaf y)), Inst @"w" w) + ?? cp `at` (Inst @"c" c, Inst @"t" (sFork (sLeaf y) (sLeaf a)), Inst @"w" w) + ?? cp `at` (Inst @"c" changed, Inst @"t" (sFork (sLeaf a) (sLeaf b)), Inst @"w" w) + ?? cp `at` (Inst @"c" changed, Inst @"t" (sFork (sLeaf b) (sLeaf a)), Inst @"w" w) + ?? cc `at` (Inst @"c" c, Inst @"x" a, Inst @"y" y) + ?? cc `at` (Inst @"c" c, Inst @"x" y, Inst @"y" a) + ?? cc `at` (Inst @"c" changed, Inst @"x" a, Inst @"y" b) + ?? cc `at` (Inst @"c" changed, Inst @"x" b, Inst @"y" a) + =: sTrue + =: qed + +-- | After placing the first minimum, the other selected slot can receive +-- the second. When the minima differ there is only one copy of the first. +-- +-- >>> runTP remainingBound +-- Lemma: countPlug Q.E.D. +-- Lemma: outsideCountNonNegative Q.E.D. +-- Lemma: remainingBound +-- Step: 1 Q.E.D. +-- Result: Q.E.D. +-- Functions proven terminating: count, outsideCount, plug, replace, replaceOutside +-- [Proven] remainingBound :: Ɐc ∷ Context → Ɐa ∷ Integer → Ɐb ∷ Integer → Ɐx ∷ Integer → Ɐy ∷ Integer → Bool +remainingBound :: TP (Proof (Forall "c" Context -> Forall "a" Integer -> Forall "b" Integer + -> Forall "x" Integer -> Forall "y" Integer -> SBool)) +remainingBound = do + cp <- recall countPlug + cn <- recall outsideCountNonNegative + + calc "remainingBound" + (\(Forall c) (Forall a) (Forall b) (Forall x) (Forall y) -> + a .<= b .&& a .<= x .&& a .<= y .&& (x .== a .|| b .<= x) .&& (y .== a .|| b .<= y) + .&& (a .< b .=> count a (rebuildPair (sSiblingPair c x y)) .== 1) .=> + b .<= secondWeight (placeFirst a (sSiblingPair c x y))) $ \c a b x y -> + [a .<= b, a .<= x, a .<= y, x .== a .|| b .<= x, y .== a .|| b .<= y, + a .< b .=> count a (rebuildPair (sSiblingPair c x y)) .== 1] + |- b .<= secondWeight (placeFirst a (sSiblingPair c x y)) + ?? cp `at` (Inst @"c" c, Inst @"t" (sFork (sLeaf x) (sLeaf y)), Inst @"w" a) + ?? cn `at` (Inst @"c" c, Inst @"w" a) + =: sTrue + =: qed + +-- * The greedy-choice theorem + +-- | The two smallest positive weights, counting occurrences rather than +-- distinct values. If they differ, the smallest occurs exactly once. +-- +-- >>> prove $ smallestTwo 1 1 exampleTree +-- Q.E.D. +-- +-- >>> prove $ sNot $ smallestTwo 1 3 exampleTree +-- Q.E.D. +-- +-- >>> prove $ smallestTwo 1 2 $ replace 1 2 exampleTree +-- Q.E.D. +smallestTwo :: SInteger -> SInteger -> STree -> SBool +smallestTwo a b t = isFork t .&& a .> 0 .&& a .<= b + .&& count a t .> 0 .&& count b t .>= 1 + ite (a .== b) 1 0 + .&& (a .< b .=> count a t .== 1) + .&& quantifiedBool (\(Forall @"w" w) -> count w t .> 0 .=> a .<= w .&& (w .== a .|| b .<= w)) + +-- | Arrange the two minimum weights as siblings at maximum depth. +-- The precondition is 'smallestTwo'; 'greedyChoice' proves the resulting +-- tree preserves multiplicities and does not increase cost. +-- +-- >>> unliteral $ rebuildPair $ greedyPair 1 1 exampleTree +-- Just (Fork (Leaf 3) (Fork (Leaf 5) (Fork (Leaf 1) (Leaf 1)))) +-- +-- >>> cost $ rebuildPair $ greedyPair 1 1 exampleTree +-- 19 :: SInteger +greedyPair :: SInteger -> SInteger -> STree -> SSiblingPair +greedyPair a b t = placeSecond b (placeFirst a (deepestPair t)) + +-- | Each selected leaf obeys the bounds on the two minimum weights. +-- +-- >>> runTP selectedBounds +-- Lemma: deepestPairCorrect Q.E.D. +-- Lemma: countPlug Q.E.D. +-- Lemma: outsideCountNonNegative Q.E.D. +-- Lemma: selectedBounds +-- Step: 1 Q.E.D. +-- Result: Q.E.D. +-- Functions proven terminating: count, deepestPair, depth, height, outsideCount, plug +-- [Proven] selectedBounds :: Ɐt ∷ Tree → Ɐa ∷ Integer → Ɐb ∷ Integer → Bool +selectedBounds :: TP (Proof (Forall "t" Tree -> Forall "a" Integer -> Forall "b" Integer -> SBool)) +selectedBounds = do + dp <- recall deepestPairCorrect + cp <- recall countPlug + cn <- recall outsideCountNonNegative + + calc "selectedBounds" + (\(Forall t) (Forall a) (Forall b) -> + let p = deepestPair t + x = firstWeight p + y = secondWeight p + in smallestTwo a b t .=> a .<= x .&& a .<= y .&& (x .== a .|| b .<= x) .&& (y .== a .|| b .<= y)) $ \t a b -> + let p = deepestPair t + c = pairContext p + x = firstWeight p + y = secondWeight p + leaves = sFork (sLeaf x) (sLeaf y) + in [smallestTwo a b t] |- a .<= x .&& a .<= y .&& (x .== a .|| b .<= x) .&& (y .== a .|| b .<= y) + ?? dp `at` Inst @"t" t + ?? cp `at` (Inst @"c" c, Inst @"t" leaves, Inst @"w" x) + ?? cp `at` (Inst @"c" c, Inst @"t" leaves, Inst @"w" y) + ?? cn `at` (Inst @"c" c, Inst @"w" x) + ?? cn `at` (Inst @"c" c, Inst @"w" y) + =: sTrue + =: qed + +-- | Huffman's greedy-choice lemma, for an arbitrary full binary tree: +-- the two minimum weights can be made siblings without increasing cost +-- or changing any leaf multiplicity. No tree-size bound is imposed. +-- 'huffmanOptimal' uses this step to reduce each competing tree before +-- applying its induction hypothesis. +-- +-- >>> runTP greedyChoice +-- Lemma: deepestPairCorrect Q.E.D. +-- Lemma: deepestPairBound Q.E.D. +-- Lemma: selectedBounds Q.E.D. +-- Lemma: placeFirstCorrect Q.E.D. +-- Lemma: placeSecondCorrect Q.E.D. +-- Lemma: remainingBound Q.E.D. +-- Lemma: greedyChoice +-- Step: 1 Q.E.D. +-- Result: Q.E.D. +-- Functions proven terminating: +-- cost, count, deepestPair, depth, height, leafDepth, locate, outsideCost, outsideCount, +-- outsideWeight, plug, replace, replaceOutside, weight +-- [Proven] greedyChoice :: Ɐt ∷ Tree → Ɐa ∷ Integer → Ɐb ∷ Integer → Ɐw ∷ Integer → Bool +greedyChoice :: TP (Proof (Forall "t" Tree -> Forall "a" Integer -> Forall "b" Integer -> Forall "w" Integer -> SBool)) +greedyChoice = do + dp <- recall deepestPairCorrect + db <- recall deepestPairBound + sb <- recall selectedBounds + pf <- recall placeFirstCorrect + ps <- recall placeSecondCorrect + rb <- recall remainingBound + + calc "greedyChoice" + (\(Forall t) (Forall a) (Forall b) (Forall w) -> + let q = greedyPair a b t + in smallestTwo a b t .=> firstWeight q .== a .&& secondWeight q .== b + .&& count w (rebuildPair q) .== count w t .&& cost (rebuildPair q) .<= cost t) $ \t a b w -> + let p = deepestPair t + c = pairContext p + x = firstWeight p + y = secondWeight p + p1 = placeFirst a p + c1 = pairContext p1 + y1 = secondWeight p1 + q = greedyPair a b t + in [smallestTwo a b t] |- firstWeight q .== a .&& secondWeight q .== b + .&& count w (rebuildPair q) .== count w t .&& cost (rebuildPair q) .<= cost t + ?? dp `at` Inst @"t" t + ?? db `at` Inst @"t" t + ?? sb `at` (Inst @"t" t, Inst @"a" a, Inst @"b" b) + ?? pf `at` (Inst @"c" c, Inst @"a" a, Inst @"x" x, Inst @"y" y, Inst @"w" w) + ?? pf `at` (Inst @"c" c, Inst @"a" a, Inst @"x" x, Inst @"y" y, Inst @"w" b) + ?? rb `at` (Inst @"c" c, Inst @"a" a, Inst @"b" b, Inst @"x" x, Inst @"y" y) + ?? ps `at` (Inst @"c" c1, Inst @"a" a, Inst @"b" b, Inst @"y" y1, Inst @"w" w) + =: sTrue + =: qed + +-- * The sorted frequency queue + +-- | Multiplicity of a frequency in the input queue. +-- +-- >>> frequencyCount 1 $ literal [1, 1, 3, 5] +-- 2 :: SInteger +frequencyCount :: SInteger -> SList Integer -> SInteger +frequencyCount = smtFunction "frequencyCount" $ \w xs -> [sCase| xs of + [] -> 0 + x : ys -> ite (w .== x) 1 0 + frequencyCount w ys + |] + +-- | Every frequency in the queue is at least the given lower bound. +-- +-- >>> above 3 $ literal [3, 5] +-- True +above :: SInteger -> SList Integer -> SBool +above = smtFunction "above" $ \lo xs -> [sCase| xs of + [] -> sTrue + x : ys -> lo .<= x .&& above lo ys + |] + +-- | A nondecreasing queue of positive integer frequencies. +-- +-- >>> ordered $ literal [1, 1, 3, 5] +-- True +-- +-- >>> ordered $ literal [1, 0] +-- False +ordered :: SList Integer -> SBool +ordered = smtFunction "ordered" $ \xs -> [sCase| xs of + [] -> sTrue + x : ys -> x .> 0 .&& above x ys .&& ordered ys + |] + +-- | Insert a frequency into a sorted queue. +-- +-- >>> unliteral $ insert 4 $ literal [1, 3, 5] +-- Just [1,3,4,5] +insert :: SInteger -> SList Integer -> SList Integer +insert = smtFunction "insert" $ \e xs -> [sCase| xs of + [] -> [e] + x : ys | e .<= x -> e .: xs + | True -> x .: insert e ys + |] + +-- | Insertion adds one queue entry. This supplies the termination argument +-- for Huffman's recursion, where two entries are replaced by one. +-- +-- >>> runTP insertLength +-- Lemma: insertLength Q.E.D. +-- Functions proven terminating: insert +-- [Proven] insertLength :: Ɐxs ∷ [Integer] → Ɐe ∷ Integer → Bool +insertLength :: TP (Proof (Forall "xs" [Integer] -> Forall "e" Integer -> SBool)) +insertLength = inductiveLemma "insertLength" (\(Forall xs) (Forall e) -> L.length (insert e xs) .== 1 + L.length xs) [] + +-- | Queue multiplicities are nonnegative. +-- +-- >>> runTP frequencyCountNonNegative +-- Lemma: frequencyCountNonNegative Q.E.D. +-- Functions proven terminating: frequencyCount +-- [Proven] frequencyCountNonNegative :: Ɐxs ∷ [Integer] → Ɐw ∷ Integer → Bool +frequencyCountNonNegative :: TP (Proof (Forall "xs" [Integer] -> Forall "w" Integer -> SBool)) +frequencyCountNonNegative = inductiveLemma "frequencyCountNonNegative" (\(Forall xs) (Forall w) -> frequencyCount w xs .>= 0) [] + +-- | Insertion changes exactly the multiplicity of the inserted frequency. +-- +-- >>> runTP insertCount +-- Lemma: insertCount Q.E.D. +-- Functions proven terminating: frequencyCount, insert +-- [Proven] insertCount :: Ɐxs ∷ [Integer] → Ɐe ∷ Integer → Ɐw ∷ Integer → Bool +insertCount :: TP (Proof (Forall "xs" [Integer] -> Forall "e" Integer -> Forall "w" Integer -> SBool)) +insertCount = inductiveLemma "insertCount" (\(Forall xs) (Forall e) (Forall w) -> frequencyCount w (insert e xs) .== frequencyCount w xs + ite (w .== e) 1 0) [] + +-- | Insertion preserves a lower bound precisely when the new entry meets it. +-- CVC5 handles the recursive sequence reasoning more readily than Z3. +-- +-- >>> runTP insertAbove +-- Inductive lemma: insertAbove +-- Step: Base Q.E.D. +-- Step: 1 Q.E.D. +-- Step: 2 Q.E.D. +-- Result: Q.E.D. +-- Functions proven terminating: above, insert +-- [Proven] insertAbove :: Ɐxs ∷ [Integer] → Ɐe ∷ Integer → Ɐlo ∷ Integer → Bool +insertAbove :: TP (Proof (Forall "xs" [Integer] -> Forall "e" Integer -> Forall "lo" Integer -> SBool)) +insertAbove = inductWith cvc5 "insertAbove" + (\(Forall xs) (Forall e) (Forall lo) -> above lo (insert e xs) .== (lo .<= e .&& above lo xs)) $ \ih (x, xs) e lo -> + [] |- above lo (insert e (x .: xs)) + =: ite (e .<= x) (lo .<= e .&& lo .<= x .&& above lo xs) (lo .<= x .&& above lo (insert e xs)) + ?? ih `at` (Inst @"e" e, Inst @"lo" lo) + =: lo .<= e .&& above lo (x .: xs) + =: qed + +-- | Lowering a queue's lower bound preserves the bound. +-- +-- >>> runTP aboveWeaken +-- Lemma: aboveWeaken Q.E.D. +-- Functions proven terminating: above +-- [Proven] aboveWeaken :: Ɐxs ∷ [Integer] → Ɐlo ∷ Integer → Ɐhi ∷ Integer → Bool +aboveWeaken :: TP (Proof (Forall "xs" [Integer] -> Forall "lo" Integer -> Forall "hi" Integer -> SBool)) +aboveWeaken = inductiveLemma "aboveWeaken" (\(Forall xs) (Forall lo) (Forall hi) -> lo .<= hi .&& above hi xs .=> above lo xs) [] + +-- | Inserting a positive frequency preserves a sorted positive queue. +-- +-- >>> runTP insertOrdered +-- Lemma: insertAbove Q.E.D. +-- Lemma: aboveWeaken Q.E.D. +-- Inductive lemma: insertOrdered +-- Step: Base Q.E.D. +-- Step: 1 Q.E.D. +-- Step: 2 Q.E.D. +-- Result: Q.E.D. +-- Functions proven terminating: above, insert, ordered +-- [Proven] insertOrdered :: Ɐxs ∷ [Integer] → Ɐe ∷ Integer → Bool +insertOrdered :: TP (Proof (Forall "xs" [Integer] -> Forall "e" Integer -> SBool)) +insertOrdered = do + ia <- recall insertAbove + aw <- recall aboveWeaken + + inductWith cvc5 "insertOrdered" + (\(Forall xs) (Forall e) -> ordered xs .&& e .> 0 .=> ordered (insert e xs)) $ \ih (x, xs) e -> + [ordered (x .: xs), e .> 0] |- ordered (insert e (x .: xs)) + =: ite (e .<= x) (e .> 0 .&& above e (x .: xs) .&& ordered (x .: xs)) + (x .> 0 .&& above x (insert e xs) .&& ordered (insert e xs)) + ?? aw `at` (Inst @"xs" xs, Inst @"lo" e, Inst @"hi" x) + ?? ia `at` (Inst @"xs" xs, Inst @"e" e, Inst @"lo" x) + ?? ih `at` Inst @"e" e + =: sTrue + =: qed + +-- | Any frequency occurring in a bounded queue satisfies its lower bound. +-- +-- >>> runTP aboveCount +-- Lemma: aboveCount Q.E.D. +-- Functions proven terminating: above, frequencyCount +-- [Proven] aboveCount :: Ɐxs ∷ [Integer] → Ɐlo ∷ Integer → Ɐw ∷ Integer → Bool +aboveCount :: TP (Proof (Forall "xs" [Integer] -> Forall "lo" Integer -> Forall "w" Integer -> SBool)) +aboveCount = inductiveLemma "aboveCount" (\(Forall xs) (Forall lo) (Forall w) -> above lo xs .&& frequencyCount w xs .> 0 .=> lo .<= w) [] + +-- | Every frequency occurring in a sorted positive queue is positive. +-- +-- >>> runTP orderedPositive +-- Lemma: orderedPositive Q.E.D. +-- Functions proven terminating: above, frequencyCount, ordered +-- [Proven] orderedPositive :: Ɐxs ∷ [Integer] → Ɐw ∷ Integer → Bool +orderedPositive :: TP (Proof (Forall "xs" [Integer] -> Forall "w" Integer -> SBool)) +orderedPositive = inductiveLemmaWith cvc5 "orderedPositive" (\(Forall xs) (Forall w) -> ordered xs .&& frequencyCount w xs .> 0 .=> w .> 0) [] + +-- * Huffman construction and its invariants + +-- | Replace one occurrence of @a+b@ by sibling leaves @a@ and @b@. +-- The precondition is that the summed weight occurs in the tree. +-- +-- >>> unliteral $ expand 1 1 $ sFork (sLeaf 2) (sLeaf 3) +-- Just (Fork (Fork (Leaf 1) (Leaf 1)) (Leaf 3)) +expand :: SInteger -> SInteger -> STree -> STree +expand a b t = plug (locate (a+b) t) (sFork (sLeaf a) (sLeaf b)) + +-- | Construct a Huffman tree from a nonempty sorted positive queue. +-- The empty case is a placeholder, excluded by the correctness theorem. +-- Each recursive call removes the two minimum frequencies, inserts their sum, +-- and expands one occurrence of that sum in the resulting tree. +-- +-- This is the recursive formulation commonly used in proofs. The usual +-- algorithm maintains a queue of trees and joins the two lightest; it can +-- produce a different tree shape with the same optimal cost. Here 'locate' +-- chooses the first leaf with the summed weight, even if an original input +-- frequency equals that sum. Any such leaf is suitable in this weight-only +-- model, which does not track the identities of symbols or merged subtrees. +-- +-- >>> unliteral $ huffman $ literal [1, 1, 3, 5] +-- Just (Fork (Fork (Fork (Leaf 1) (Leaf 1)) (Leaf 3)) (Leaf 5)) +-- +-- >>> cost $ huffman $ literal [1, 1, 3, 5] +-- 17 :: SInteger +-- +-- >>> cost $ huffman $ literal [5, 9, 12, 13, 16, 45] +-- 224 :: SInteger +-- +-- >>> cost $ huffman $ literal [7] +-- 0 :: SInteger +huffman :: SList Integer -> STree +huffman = smtFunctionWithMeasure "huffman" (L.length, [measureLemma insertLength]) $ \xs -> + [sCase| xs of + [] -> sLeaf 0 + [a] -> sLeaf a + a : b : ys -> expand a b (huffman (insert (a+b) ys)) + |] + +-- | Expanding a summed leaf removes one copy of the sum and adds the two +-- original frequencies. Coincident frequencies are counted with multiplicity. +-- +-- >>> runTP expandCount +-- Lemma: locateCorrect Q.E.D. +-- Lemma: countPlug Q.E.D. +-- Lemma: expandCount +-- Step: 1 Q.E.D. +-- Step: 2 Q.E.D. +-- Result: Q.E.D. +-- Functions proven terminating: count, depth, leafDepth, locate, outsideCount, plug, replace +-- [Proven] expandCount :: Ɐt ∷ Tree → Ɐa ∷ Integer → Ɐb ∷ Integer → Ɐw ∷ Integer → Bool +expandCount :: TP (Proof (Forall "t" Tree -> Forall "a" Integer -> Forall "b" Integer -> Forall "w" Integer -> SBool)) +expandCount = do + lc <- recall locateCorrect + cp <- recall countPlug + + calc "expandCount" + (\(Forall t) (Forall a) (Forall b) (Forall w) -> count (a+b) t .> 0 .=> + count w (expand a b t) .== count w t - ite (w .== a+b) 1 0 + ite (w .== a) 1 0 + ite (w .== b) 1 0) $ \t a b w -> + let c = locate (a+b) t + in [count (a+b) t .> 0] |- count w (expand a b t) + ?? cp `at` (Inst @"c" c, Inst @"t" (sFork (sLeaf a) (sLeaf b)), Inst @"w" w) + =: outsideCount w c + ite (w .== a) 1 0 + ite (w .== b) 1 0 + ?? lc `at` (Inst @"t" t, Inst @"w" (a+b), Inst @"new" (a+b)) + ?? cp `at` (Inst @"c" c, Inst @"t" (sLeaf (a+b)), Inst @"w" w) + =: count w t - ite (w .== a+b) 1 0 + ite (w .== a) 1 0 + ite (w .== b) 1 0 + =: qed + +-- | Expanding a summed leaf increases cost by exactly the sum, independently +-- of where that occurrence lies in the tree. +-- +-- >>> runTP expandCost +-- Lemma: locateCorrect Q.E.D. +-- Lemma: contraction Q.E.D. +-- Lemma: expandCost +-- Step: 1 Q.E.D. +-- Step: 2 Q.E.D. +-- Result: Q.E.D. +-- Functions proven terminating: cost, count, depth, leafDepth, locate, outsideCost, outsideWeight, plug, replace, weight +-- [Proven] expandCost :: Ɐt ∷ Tree → Ɐa ∷ Integer → Ɐb ∷ Integer → Bool +expandCost :: TP (Proof (Forall "t" Tree -> Forall "a" Integer -> Forall "b" Integer -> SBool)) +expandCost = do + lc <- recall locateCorrect + co <- recall contraction + + calc "expandCost" + (\(Forall t) (Forall a) (Forall b) -> count (a+b) t .> 0 .=> cost (expand a b t) .== cost t + a+b) $ \t a b -> + [count (a+b) t .> 0] |- cost (expand a b t) + ?? co `at` (Inst @"c" (locate (a+b) t), Inst @"a" a, Inst @"b" b) + =: cost (plug (locate (a+b) t) (sLeaf (a+b))) + a+b + ?? lc `at` (Inst @"t" t, Inst @"w" (a+b), Inst @"new" (a+b)) + =: cost t + a+b + =: qed + +-- | Huffman's construction preserves every input frequency, for any +-- nonempty queue. Sorting and positivity are needed only for optimality. +-- +-- >>> runTP huffmanCounts +-- Lemma: insertLength Q.E.D. +-- Lemma: insertCount Q.E.D. +-- Lemma: frequencyCountNonNegative Q.E.D. +-- Lemma: expandCount Q.E.D. +-- Inductive lemma (strong): huffmanCounts +-- Step: Measure is non-negative Q.E.D. +-- Step: 1 (3 way case split) +-- Step: 1.1 Q.E.D. +-- Step: 1.2 Q.E.D. +-- Step: 1.3.1 Q.E.D. +-- Step: 1.3.2 Q.E.D. +-- Step: 1.3.3 Q.E.D. +-- Step: 1.3.4 Q.E.D. +-- Step: 1.3.5 Q.E.D. +-- Step: 1.Completeness Q.E.D. +-- Result: Q.E.D. +-- Functions proven terminating: +-- count, depth, frequencyCount, huffman, insert, leafDepth, locate, outsideCount, plug, replace +-- [Proven] huffmanCounts :: Ɐxs ∷ [Integer] → Ɐw ∷ Integer → Bool +huffmanCounts :: TP (Proof (Forall "xs" [Integer] -> Forall "w" Integer -> SBool)) +huffmanCounts = do + il <- recall insertLength + ic <- recall insertCount + cn <- recall frequencyCountNonNegative + ec <- recall expandCount + + sInductWith cvc5 "huffmanCounts" + (\(Forall xs) (Forall w) -> sNot (L.null xs) .=> count w (huffman xs) .== frequencyCount w xs) + (\xs _ -> L.length xs, []) $ \ih xs w -> + [sNot (L.null xs)] |- count w (huffman xs) + =: [pCase| xs of + [] -> (0 :: SInteger) =: qed + + [a] -> ite (w .== a) (1 :: SInteger) 0 =: qed + + a : b : ys -> let next = insert (a+b) ys + t = huffman next + in count w (expand a b t) + ?? il `at` (Inst @"xs" ys, Inst @"e" (a+b)) + ?? ic `at` (Inst @"xs" ys, Inst @"e" (a+b), Inst @"w" (a+b)) + ?? cn `at` (Inst @"xs" ys, Inst @"w" (a+b)) + ?? ih `at` (Inst @"xs" next, Inst @"w" (a+b)) + ?? ec `at` (Inst @"t" t, Inst @"a" a, Inst @"b" b, Inst @"w" w) + =: count w t - ite (w .== a+b) 1 0 + ite (w .== a) 1 0 + ite (w .== b) 1 0 + ?? il `at` (Inst @"xs" ys, Inst @"e" (a+b)) + ?? ih `at` (Inst @"xs" next, Inst @"w" w) + =: frequencyCount w next - ite (w .== a+b) 1 0 + ite (w .== a) 1 0 + ite (w .== b) 1 0 + ?? ic `at` (Inst @"xs" ys, Inst @"e" (a+b), Inst @"w" w) + =: frequencyCount w ys + ite (w .== a) 1 0 + ite (w .== b) 1 0 + =: frequencyCount w (a .: b .: ys) + =: qed + |] + +-- | Cost recurrence of the constructed Huffman tree, justified by actually +-- expanding a leaf in the recursive result. +-- +-- >>> runTP huffmanCostStep +-- Lemma: huffmanCounts Q.E.D. +-- Lemma: insertLength Q.E.D. [Cached] +-- Lemma: insertCount Q.E.D. [Cached] +-- Lemma: frequencyCountNonNegative Q.E.D. [Cached] +-- Lemma: expandCost Q.E.D. +-- Lemma: huffmanCostStep +-- Step: 1 Q.E.D. +-- Step: 2 Q.E.D. +-- Result: Q.E.D. +-- Functions proven terminating: +-- cost, count, depth, frequencyCount, huffman, insert, leafDepth, locate, outsideCost, +-- outsideCount, outsideWeight, plug, replace, weight +-- [Proven] huffmanCostStep :: Ɐa ∷ Integer → Ɐb ∷ Integer → Ɐxs ∷ [Integer] → Bool +huffmanCostStep :: TP (Proof (Forall "a" Integer -> Forall "b" Integer -> Forall "xs" [Integer] -> SBool)) +huffmanCostStep = do + hc <- recall huffmanCounts + il <- recall insertLength + ic <- recall insertCount + cn <- recall frequencyCountNonNegative + ec <- recall expandCost + + calcWith cvc5 "huffmanCostStep" + (\(Forall a) (Forall b) (Forall xs) -> + cost (huffman (a .: b .: xs)) .== cost (huffman (insert (a+b) xs)) + a+b) $ \a b xs -> + let next = insert (a+b) xs + t = huffman next + in [] |- cost (huffman (a .: b .: xs)) + =: cost (expand a b t) + ?? il `at` (Inst @"xs" xs, Inst @"e" (a+b)) + ?? ic `at` (Inst @"xs" xs, Inst @"e" (a+b), Inst @"w" (a+b)) + ?? cn `at` (Inst @"xs" xs, Inst @"w" (a+b)) + ?? hc `at` (Inst @"xs" next, Inst @"w" (a+b)) + ?? ec `at` (Inst @"t" t, Inst @"a" a, Inst @"b" b) + =: cost t + a+b + =: qed + +-- * Reducing a competing tree + +-- | The tree and the frequency queue describe the same multiset of weights. +-- +-- >>> prove $ sameWeights (literal [1, 1, 3, 5]) exampleTree +-- Q.E.D. +sameWeights :: SList Integer -> STree -> SBool +sameWeights xs t = quantifiedBool (\(Forall @"w" w) -> count w t .== frequencyCount w xs) + +-- | All weights occurring in the tree are nonnegative. +-- +-- >>> prove $ nonnegative exampleTree +-- Q.E.D. +nonnegative :: STree -> SBool +nonnegative t = quantifiedBool (\(Forall @"w" w) -> count w t .> 0 .=> w .>= 0) + +-- | A tree with nonnegative leaf weights has nonnegative weight and cost. +-- +-- >>> runTP nonnegativeCost +-- Lemma: countNonNegative Q.E.D. +-- Lemma: nonnegativeCost Q.E.D. +-- Functions proven terminating: cost, count, weight +-- [Proven] nonnegativeCost :: Ɐt ∷ Tree → Bool +nonnegativeCost :: TP (Proof (Forall "t" Tree -> SBool)) +nonnegativeCost = do + cn <- recall countNonNegative + + inductiveLemma "nonnegativeCost" + (\(Forall t) -> nonnegative t .=> weight t .>= 0 .&& cost t .>= 0) + [proofOf cn] + +-- | Every competing tree for a sorted positive queue has nonnegative cost. +-- +-- >>> runTP competitorCost +-- Lemma: orderedPositive Q.E.D. +-- Lemma: nonnegativeCost Q.E.D. +-- Lemma: competitorCost Q.E.D. +-- Functions proven terminating: above, cost, count, frequencyCount, ordered, weight +-- [Proven] competitorCost :: Ɐxs ∷ [Integer] → Ɐt ∷ Tree → Bool +competitorCost :: TP (Proof (Forall "xs" [Integer] -> Forall "t" Tree -> SBool)) +competitorCost = do + op <- recall orderedPositive + nc <- recall nonnegativeCost + + lemmaWith cvc5 "competitorCost" + (\(Forall xs) (Forall t) -> ordered xs .&& sameWeights xs t .=> cost t .>= 0) + [proofOf op, proofOf nc] + +-- | The first two queue entries bound every weight in a competing tree. +-- +-- >>> runTP queueBounds +-- Lemma: aboveCount Q.E.D. +-- Lemma: queueBounds +-- Step: 1 Q.E.D. +-- Result: Q.E.D. +-- Functions proven terminating: above, count, frequencyCount, ordered +-- [Proven] queueBounds :: Ɐa ∷ Integer → Ɐb ∷ Integer → Ɐxs ∷ [Integer] → Ɐt ∷ Tree → Ɐw ∷ Integer → Bool +queueBounds :: TP (Proof (Forall "a" Integer -> Forall "b" Integer -> Forall "xs" [Integer] -> Forall "t" Tree -> Forall "w" Integer -> SBool)) +queueBounds = do + ac <- recall aboveCount + + calcWith cvc5 "queueBounds" + (\(Forall a) (Forall b) (Forall xs) (Forall t) (Forall w) -> + ordered (a .: b .: xs) .&& sameWeights (a .: b .: xs) t .&& count w t .> 0 .=> + a .<= w .&& (w .== a .|| b .<= w)) $ \a b xs t w -> + [ordered (a .: b .: xs), sameWeights (a .: b .: xs) t, count w t .> 0] |- a .<= w .&& (w .== a .|| b .<= w) + ?? ac `at` (Inst @"xs" xs, Inst @"lo" b, Inst @"w" w) + =: sTrue + =: qed + +-- | The first two entries of a sorted positive queue satisfy the exact +-- minimum-weight precondition used by the tree exchange theorem. +-- +-- >>> runTP queueMinima +-- Lemma: queueBounds Q.E.D. +-- Lemma: aboveCount Q.E.D. [Cached] +-- Lemma: frequencyCountNonNegative Q.E.D. +-- Lemma: queueMinima Q.E.D. +-- Functions proven terminating: above, count, frequencyCount, ordered +-- [Proven] queueMinima :: Ɐa ∷ Integer → Ɐb ∷ Integer → Ɐxs ∷ [Integer] → Ɐt ∷ Tree → Bool +queueMinima :: TP (Proof (Forall "a" Integer -> Forall "b" Integer -> Forall "xs" [Integer] -> Forall "t" Tree -> SBool)) +queueMinima = do + qb <- recall queueBounds + ac <- recall aboveCount + cn <- recall frequencyCountNonNegative + + lemmaWith cvc5 "queueMinima" + (\(Forall a) (Forall b) (Forall xs) (Forall t) -> + ordered (a .: b .: xs) .&& sameWeights (a .: b .: xs) t .=> smallestTwo a b t) + [proofOf qb, proofOf ac, proofOf cn] + +-- | Apply the greedy exchange to a competing tree, then contract its two +-- minimum-weight sibling leaves to their sum. +-- +-- >>> unliteral $ contractGreedy 1 1 exampleTree +-- Just (Fork (Leaf 3) (Fork (Leaf 5) (Leaf 2))) +contractGreedy :: SInteger -> SInteger -> STree -> STree +contractGreedy a b t = plug (pairContext (greedyPair a b t)) (sLeaf (a+b)) + +-- | Exact frequency change after exchanging and contracting the minima. +-- +-- >>> runTP contractGreedyCount +-- Lemma: greedyChoice Q.E.D. +-- Lemma: countPlug Q.E.D. [Cached] +-- Lemma: contractGreedyCount +-- Step: 1 Q.E.D. +-- Step: 2 Q.E.D. +-- Result: Q.E.D. +-- Functions proven terminating: +-- cost, count, deepestPair, depth, height, leafDepth, locate, outsideCost, outsideCount, +-- outsideWeight, plug, replace, replaceOutside, weight +-- [Proven] contractGreedyCount :: Ɐt ∷ Tree → Ɐa ∷ Integer → Ɐb ∷ Integer → Ɐw ∷ Integer → Bool +contractGreedyCount :: TP (Proof (Forall "t" Tree -> Forall "a" Integer -> Forall "b" Integer -> Forall "w" Integer -> SBool)) +contractGreedyCount = do + gc <- recall greedyChoice + cp <- recall countPlug + + calc "contractGreedyCount" + (\(Forall t) (Forall a) (Forall b) (Forall w) -> smallestTwo a b t .=> + count w (contractGreedy a b t) .== count w t - ite (w .== a) 1 0 - ite (w .== b) 1 0 + ite (w .== a+b) 1 0) $ \t a b w -> + let c = pairContext (greedyPair a b t) + in [smallestTwo a b t] |- count w (contractGreedy a b t) + ?? cp `at` (Inst @"c" c, Inst @"t" (sLeaf (a+b)), Inst @"w" w) + =: outsideCount w c + ite (w .== a+b) 1 0 + ?? gc `at` (Inst @"t" t, Inst @"a" a, Inst @"b" b, Inst @"w" w) + ?? cp `at` (Inst @"c" c, Inst @"t" (sFork (sLeaf a) (sLeaf b)), Inst @"w" w) + =: count w t - ite (w .== a) 1 0 - ite (w .== b) 1 0 + ite (w .== a+b) 1 0 + =: qed + +-- | Exchanging and contracting the minima saves at least their sum. +-- +-- >>> runTP contractGreedyCost +-- Lemma: greedyChoice Q.E.D. +-- Lemma: contraction Q.E.D. +-- Lemma: contractGreedyCost +-- Step: 1 Q.E.D. +-- Result: Q.E.D. +-- Functions proven terminating: +-- cost, count, deepestPair, depth, height, leafDepth, locate, outsideCost, outsideCount, +-- outsideWeight, plug, replace, replaceOutside, weight +-- [Proven] contractGreedyCost :: Ɐt ∷ Tree → Ɐa ∷ Integer → Ɐb ∷ Integer → Bool +contractGreedyCost :: TP (Proof (Forall "t" Tree -> Forall "a" Integer -> Forall "b" Integer -> SBool)) +contractGreedyCost = do + gc <- recall greedyChoice + co <- recall contraction + + calc "contractGreedyCost" + (\(Forall t) (Forall a) (Forall b) -> smallestTwo a b t .=> cost (contractGreedy a b t) + a+b .<= cost t) $ \t a b -> + let c = pairContext (greedyPair a b t) + in [smallestTwo a b t] |- cost (contractGreedy a b t) + a+b .<= cost t + ?? co `at` (Inst @"c" c, Inst @"a" a, Inst @"b" b) + ?? gc `at` (Inst @"t" t, Inst @"a" a, Inst @"b" b, Inst @"w" a) + =: sTrue + =: qed + +-- | One frequency's multiplicity agrees between the contracted competitor +-- and the next queue, including collisions with the newly inserted sum. +-- +-- >>> runTP contractQueueCount +-- Lemma: queueMinima Q.E.D. +-- Lemma: contractGreedyCount Q.E.D. +-- Lemma: insertCount Q.E.D. +-- Lemma: contractQueueCount +-- Step: 1 Q.E.D. +-- Step: 2 Q.E.D. +-- Result: Q.E.D. +-- Functions proven terminating: +-- above, cost, count, deepestPair, depth, frequencyCount, height, insert, leafDepth, +-- locate, ordered, outsideCost, outsideCount, outsideWeight, plug, replace, replaceOutside, weight +-- [Proven] contractQueueCount :: Ɐa ∷ Integer → Ɐb ∷ Integer → Ɐxs ∷ [Integer] → Ɐt ∷ Tree → Ɐw ∷ Integer → Bool +contractQueueCount :: TP (Proof (Forall "a" Integer -> Forall "b" Integer -> Forall "xs" [Integer] + -> Forall "t" Tree -> Forall "w" Integer -> SBool)) +contractQueueCount = do + qm <- recall queueMinima + cc <- recall contractGreedyCount + ic <- recall insertCount + + calcWith cvc5 "contractQueueCount" + (\(Forall a) (Forall b) (Forall xs) (Forall t) (Forall w) -> + ordered (a .: b .: xs) .&& sameWeights (a .: b .: xs) t .=> + count w (contractGreedy a b t) .== frequencyCount w (insert (a+b) xs)) $ \a b xs t w -> + [ordered (a .: b .: xs), sameWeights (a .: b .: xs) t] |- count w (contractGreedy a b t) + ?? qm `at` (Inst @"a" a, Inst @"b" b, Inst @"xs" xs, Inst @"t" t) + ?? cc `at` (Inst @"t" t, Inst @"a" a, Inst @"b" b, Inst @"w" w) + =: frequencyCount w xs + ite (w .== a+b) 1 0 + ?? ic `at` (Inst @"xs" xs, Inst @"e" (a+b), Inst @"w" w) + =: frequencyCount w (insert (a+b) xs) + =: qed + +-- | The contracted competing tree matches the next Huffman queue. +-- +-- >>> runTP contractGreedyWeights +-- Lemma: contractQueueCount Q.E.D. +-- Lemma: contractGreedyWeights Q.E.D. +-- Functions proven terminating: +-- above, cost, count, deepestPair, depth, frequencyCount, height, insert, leafDepth, +-- locate, ordered, outsideCost, outsideCount, outsideWeight, plug, replace, replaceOutside, weight +-- [Proven] contractGreedyWeights :: Ɐa ∷ Integer → Ɐb ∷ Integer → Ɐxs ∷ [Integer] → Ɐt ∷ Tree → Bool +contractGreedyWeights :: TP (Proof (Forall "a" Integer -> Forall "b" Integer -> Forall "xs" [Integer] -> Forall "t" Tree -> SBool)) +contractGreedyWeights = do + cq <- recall contractQueueCount + + lemmaWith cvc5 "contractGreedyWeights" + (\(Forall a) (Forall b) (Forall xs) (Forall t) -> ordered (a .: b .: xs) .&& sameWeights (a .: b .: xs) t .=> sameWeights (insert (a+b) xs) (contractGreedy a b t)) + [proofOf cq] + +-- * Optimality and correctness + +-- | The constructed Huffman tree is no more costly than any full binary +-- tree with the same positive frequencies. Strong induction is on queue +-- length; each recursive comparison uses the exchanged, contracted competitor. +-- +-- >>> runTP huffmanOptimal +-- Lemma: insertLength Q.E.D. +-- Lemma: insertOrdered Q.E.D. +-- Lemma: huffmanCostStep Q.E.D. +-- Lemma: queueMinima Q.E.D. +-- Lemma: contractGreedyWeights Q.E.D. +-- Lemma: contractGreedyCost Q.E.D. +-- Lemma: competitorCost Q.E.D. +-- Inductive lemma (strong): huffmanOptimal +-- Step: Measure is non-negative Q.E.D. +-- Step: 1 (3 way case split) +-- Step: 1.1 Q.E.D. +-- Step: 1.2.1 Q.E.D. +-- Step: 1.2.2 Q.E.D. +-- Step: 1.3.1 Q.E.D. +-- Step: 1.3.2 Q.E.D. +-- Step: 1.3.3 Q.E.D. +-- Step: 1.Completeness Q.E.D. +-- Result: Q.E.D. +-- Functions proven terminating: +-- above, cost, count, deepestPair, depth, frequencyCount, height, huffman, insert, +-- leafDepth, locate, ordered, outsideCost, outsideCount, outsideWeight, plug, replace, +-- replaceOutside, weight +-- [Proven] huffmanOptimal :: Ɐxs ∷ [Integer] → Ɐt ∷ Tree → Bool +huffmanOptimal :: TP (Proof (Forall "xs" [Integer] -> Forall "t" Tree -> SBool)) +huffmanOptimal = do + il <- recall insertLength + io <- recall insertOrdered + hs <- recall huffmanCostStep + qm <- recall queueMinima + cw <- recall contractGreedyWeights + cc <- recall contractGreedyCost + nn <- recall competitorCost + + sInductWith cvc5 "huffmanOptimal" + (\(Forall xs) (Forall t) -> ordered xs .&& sNot (L.null xs) .&& sameWeights xs t .=> cost (huffman xs) .<= cost t) + (\xs _ -> L.length xs, []) $ \ih xs t -> + [ordered xs, sNot (L.null xs), sameWeights xs t] |- cost (huffman xs) .<= cost t + =: [pCase| xs of + [] -> sTrue =: qed + + [a] -> (0 .<= cost t) + ?? nn `at` (Inst @"xs" [a], Inst @"t" t) + =: sTrue + =: qed + + a : b : ys -> let next = insert (a+b) ys + reduced = contractGreedy a b t + in cost (huffman (a .: b .: ys)) .<= cost t + ?? hs `at` (Inst @"a" a, Inst @"b" b, Inst @"xs" ys) + =: cost (huffman next) + a+b .<= cost t + ?? il `at` (Inst @"xs" ys, Inst @"e" (a+b)) + ?? io `at` (Inst @"xs" ys, Inst @"e" (a+b)) + ?? cw `at` (Inst @"a" a, Inst @"b" b, Inst @"xs" ys, Inst @"t" t) + ?? ih `at` (Inst @"xs" next, Inst @"t" reduced) + ?? qm `at` (Inst @"a" a, Inst @"b" b, Inst @"xs" ys, Inst @"t" t) + ?? cc `at` (Inst @"t" t, Inst @"a" a, Inst @"b" b) + =: sTrue + =: qed + |] + +-- | Correctness of Huffman's construction: it preserves the supplied +-- frequencies and minimizes weighted path length among all full binary trees +-- with those frequencies. The input must be nonempty, sorted, and positive. +-- +-- >>> correctness +-- Lemma: huffmanCounts Q.E.D. +-- Lemma: huffmanOptimal Q.E.D. +-- Lemma: huffmanCorrect Q.E.D. +-- Functions proven terminating: +-- above, cost, count, deepestPair, depth, frequencyCount, height, huffman, insert, +-- leafDepth, locate, ordered, outsideCost, outsideCount, outsideWeight, plug, replace, +-- replaceOutside, weight +-- [Proven] huffmanCorrect :: Ɐxs ∷ [Integer] → Ɐt ∷ Tree → Bool +correctness :: IO (Proof (Forall "xs" [Integer] -> Forall "t" Tree -> SBool)) +correctness = runTP $ do + hc <- recall huffmanCounts + ho <- recall huffmanOptimal + + lemmaWith cvc5 "huffmanCorrect" + (\(Forall xs) (Forall t) -> ordered xs .&& sNot (L.null xs) .=> + sameWeights xs (huffman xs) .&& (sameWeights xs t .=> cost (huffman xs) .<= cost t)) + [proofOf hc, proofOf ho] diff --git a/Documentation/SBV/Examples/TP/Lists.hs b/Documentation/SBV/Examples/TP/Lists.hs --- a/Documentation/SBV/Examples/TP/Lists.hs +++ b/Documentation/SBV/Examples/TP/Lists.hs @@ -1070,11 +1070,14 @@ -- >>> runTP $ filterAppend @Integer (uninterpret "p") -- Inductive lemma: filterAppend -- Step: 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: 1 (2 way case split) +-- Step: 1.1.1 Q.E.D. +-- Step: 1.1.2 Q.E.D. +-- Step: 1.1.3 Q.E.D. +-- Step: 1.2.1 Q.E.D. +-- Step: 1.2.2 Q.E.D. +-- Step: 1.2.3 Q.E.D. +-- Step: 1.Completeness Q.E.D. -- Result: Q.E.D. -- Functions proven terminating: sbv.filter -- [Proven] filterAppend :: Ɐxs ∷ [Integer] → Ɐys ∷ [Integer] → Bool @@ -1083,24 +1086,31 @@ induct "filterAppend" (\(Forall xs) (Forall 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 + =: cases [ p x ==> x .: filter p xs ++ filter p ys + ?? ih + =: x .: filter p (xs ++ ys) + =: filter p ((x .: xs) ++ ys) + =: qed + , sNot (p x) ==> filter p xs ++ filter p ys + ?? ih + =: filter p (xs ++ ys) + =: filter p ((x .: xs) ++ ys) + =: qed + ] -- | @filter p (concat xss) == concatMap (filter p xss)@ -- -- >>> runTP $ filterConcat @Integer (uninterpret "f") -- Inductive lemma: filterAppend -- Step: 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: 1 (2 way case split) +-- Step: 1.1.1 Q.E.D. +-- Step: 1.1.2 Q.E.D. +-- Step: 1.1.3 Q.E.D. +-- Step: 1.2.1 Q.E.D. +-- Step: 1.2.2 Q.E.D. +-- Step: 1.2.3 Q.E.D. +-- Step: 1.Completeness Q.E.D. -- Result: Q.E.D. -- Inductive lemma: filterConcat -- Step: Base Q.E.D. @@ -1118,7 +1128,7 @@ (\(Forall xss) -> filter p (concat xss) .== concatMap (filter p) xss) $ \ih (xs, xss) -> [] |- filter p (concat (xs .: xss)) =: filter p (xs ++ concat xss) - ?? fa + ?? fa `at` (Inst @"xs" xs, Inst @"ys" (concat xss)) =: filter p xs ++ filter p (concat xss) ?? ih =: concatMap (filter p) (xs .: xss) @@ -1260,8 +1270,14 @@ -- Inductive lemma: appendDiff -- Step: Base Q.E.D. -- Step: 1 Q.E.D. --- Step: 2 Q.E.D. --- Step: 3 Q.E.D. +-- Step: 2 (2 way case split) +-- Step: 2.1.1 Q.E.D. +-- Step: 2.1.2 Q.E.D. +-- Step: 2.1.3 Q.E.D. +-- Step: 2.2.1 Q.E.D. +-- Step: 2.2.2 Q.E.D. +-- Step: 2.2.3 Q.E.D. +-- Step: 2.Completeness Q.E.D. -- Result: Q.E.D. -- Functions proven terminating: sbv.diff -- [Proven] appendDiff :: Ɐas ∷ [Integer] → Ɐbs ∷ [Integer] → Ɐcs ∷ [Integer] → Bool @@ -1270,10 +1286,17 @@ (\(Forall as) (Forall bs) (Forall cs) -> (as ++ bs) \\ cs .== (as \\ cs) ++ (bs \\ cs)) $ \ih (a, as) bs cs -> [] |- (a .: as ++ bs) \\ cs =: (a .: (as ++ bs)) \\ cs - =: ite (a `elem` cs) ((as ++ bs) \\ cs) (a .: ((as ++ bs) \\ cs)) - ?? ih - =: ((a .: as) \\ cs) ++ (bs \\ cs) - =: qed + =: cases [ a `elem` cs ==> (as ++ bs) \\ cs + ?? ih + =: (as \\ cs) ++ (bs \\ cs) + =: ((a .: as) \\ cs) ++ (bs \\ cs) + =: qed + , sNot (a `elem` cs) ==> a .: ((as ++ bs) \\ cs) + ?? ih + =: a .: ((as \\ cs) ++ (bs \\ cs)) + =: ((a .: as) \\ cs) ++ (bs \\ cs) + =: qed + ] -- | @as \\ (bs ++ cs) == (as \\ bs) \\ cs@ -- diff --git a/Documentation/SBV/Examples/TP/McCarthy91.hs b/Documentation/SBV/Examples/TP/McCarthy91.hs --- a/Documentation/SBV/Examples/TP/McCarthy91.hs +++ b/Documentation/SBV/Examples/TP/McCarthy91.hs @@ -81,7 +81,8 @@ \ih n -> [n .< 90] |- mcCarthy91 n ?? "unfold" =: mcCarthy91 (mcCarthy91 (n + 11)) - ?? ih `at` Inst @"n" (n + 11) + ?? ih `at` Inst @"n" (n + 11) + ?? case2 `at` Inst @"n" (n + 11) =: mcCarthy91 91 =: qed diff --git a/Documentation/SBV/Examples/Uninterpreted/EUFLogic.hs b/Documentation/SBV/Examples/Uninterpreted/EUFLogic.hs --- a/Documentation/SBV/Examples/Uninterpreted/EUFLogic.hs +++ b/Documentation/SBV/Examples/Uninterpreted/EUFLogic.hs @@ -300,8 +300,9 @@ -- -- > f (f (a) - f (b)) /= f (c), b >= a, a >= b + c, c >= 0 -- --- from --- noting that @x >= y@ is the same as @not (x < y)@. We have: +-- from Ranjit Jhala's lecture "SMT: Satisfiability Modulo Theories," given +-- in UC San Diego's CSE 291 course in Spring 2013. Note that @x >= y@ is +-- the same as @not (x < y)@. We have: -- -- >>> sat $ interpEUF example -- Satisfiable. Model: diff --git a/Documentation/SBV/Examples/WeakestPreconditions/Sum.hs b/Documentation/SBV/Examples/WeakestPreconditions/Sum.hs --- a/Documentation/SBV/Examples/WeakestPreconditions/Sum.hs +++ b/Documentation/SBV/Examples/WeakestPreconditions/Sum.hs @@ -224,8 +224,8 @@ Following proof obligation failed: ================================== Measure for loop "i < n" is negative: - State : SumS {n = 3, i = 2, s = 3} - Measure: -1 + State : SumS {n = 5, i = 3, s = 6} + Measure: -2 The failure is pretty obvious in this case: Measure produces a negative value. @@ -239,10 +239,10 @@ Following proof obligation failed: ================================== Measure for loop "i < n" does not decrease: - Before : SumS {n = 1, i = 0, s = 0} - Measure: 1 - After : SumS {n = 1, i = 1, s = 1} - Measure: 2 + Before : SumS {n = 3, i = 2, s = 3} + Measure: 5 + After : SumS {n = 3, i = 3, s = 6} + Measure: 6 Clearly, as @i@ increases, so does our bogus measure @n+i@. (Note that in this case the counterexample might have @i@ and @n@ as negative values, as the SMT solver finds a counter-example to induction, not necessarily a reachable state. Obviously, all such failures need to be addressed for the full proof.) diff --git a/README.md b/README.md --- a/README.md +++ b/README.md @@ -188,6 +188,8 @@ | [Collatz](http://hackage.haskell.org/package/sbv/docs/Documentation-SBV-Examples-TP-Collatz.html) | Explore properties of the Collatz sequence | | [Infinitely many primes](http://hackage.haskell.org/package/sbv/docs/Documentation-SBV-Examples-TP-Primes.html) | Prove there are infinitely many primes | | [Tautology checker](http://hackage.haskell.org/package/sbv/docs/Documentation-SBV-Examples-TP-TautologyChecker.html) | A verified BDD-style tautology checker | +| [Rubik's Cube](http://hackage.haskell.org/package/sbv/docs/Documentation-SBV-Examples-Puzzles-Rubik.html) | Find bounded shortest or two-phase face-turn solutions | +| [Huffman coding](http://hackage.haskell.org/package/sbv/docs/Documentation-SBV-Examples-TP-Huffman.html) | Prove Huffman trees minimize weighted path length for positive frequencies | Browse the full collection in `Documentation.SBV.Examples` [on Hackage](http://hackage.haskell.org/package/sbv). diff --git a/SBVTestSuite/GoldFiles/adt01.gold b/SBVTestSuite/GoldFiles/adt01.gold --- a/SBVTestSuite/GoldFiles/adt01.gold +++ b/SBVTestSuite/GoldFiles/adt01.gold @@ -98,6 +98,6 @@ (seq.++ (seq.unit false) (seq.unit true))))))))) -MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [("e",APair (AInt64 4) (AMaybe (Just (0.0,12.0,(Left 3,[False,True])))) :: ADT)], modelUIFuns = []} +MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [("e",APair (AInt64 4) (AMaybe (Just (0.0,12.0,(Left 3,[False,True])))) :: ADT)], modelUIFuns = [], modelUIBindings = Nothing} DONE.*** Solver : Z3 *** Exit code: ExitSuccess diff --git a/SBVTestSuite/GoldFiles/adt02.gold b/SBVTestSuite/GoldFiles/adt02.gold --- a/SBVTestSuite/GoldFiles/adt02.gold +++ b/SBVTestSuite/GoldFiles/adt02.gold @@ -92,6 +92,6 @@ [SEND] (get-value (s0)) [RECV] ((s0 (AList (seq.unit 2)))) -MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [("e",AList [2] :: ADT)], modelUIFuns = []} +MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [("e",AList [2] :: ADT)], modelUIFuns = [], modelUIBindings = Nothing} DONE.*** Solver : Z3 *** Exit code: ExitSuccess diff --git a/SBVTestSuite/GoldFiles/adt04.gold b/SBVTestSuite/GoldFiles/adt04.gold --- a/SBVTestSuite/GoldFiles/adt04.gold +++ b/SBVTestSuite/GoldFiles/adt04.gold @@ -119,9 +119,9 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (s0)) -[RECV] ((s0 (AInteger 3))) +[RECV] ((s0 (AInteger 5))) [GOOD] (push 1) -[GOOD] (define-fun s13 () ADT ((as AInteger ADT) 3)) +[GOOD] (define-fun s13 () ADT ((as AInteger ADT) 5)) [GOOD] (define-fun s14 () Bool (= s0 s13)) [GOOD] (define-fun s15 () Bool (not s14)) [GOOD] (assert s15) @@ -129,9 +129,9 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (s0)) -[RECV] ((s0 (AInteger 5))) +[RECV] ((s0 (AInteger 2))) [GOOD] (push 1) -[GOOD] (define-fun s16 () ADT ((as AInteger ADT) 5)) +[GOOD] (define-fun s16 () ADT ((as AInteger ADT) 2)) [GOOD] (define-fun s17 () Bool (= s0 s16)) [GOOD] (define-fun s18 () Bool (not s17)) [GOOD] (assert s18) @@ -139,9 +139,9 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (s0)) -[RECV] ((s0 (AInteger 2))) +[RECV] ((s0 (AInteger 1))) [GOOD] (push 1) -[GOOD] (define-fun s19 () ADT ((as AInteger ADT) 2)) +[GOOD] (define-fun s19 () ADT ((as AInteger ADT) 1)) [GOOD] (define-fun s20 () Bool (= s0 s19)) [GOOD] (define-fun s21 () Bool (not s20)) [GOOD] (assert s21) @@ -149,9 +149,9 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (s0)) -[RECV] ((s0 (AInteger 1))) +[RECV] ((s0 (AInteger 3))) [GOOD] (push 1) -[GOOD] (define-fun s22 () ADT ((as AInteger ADT) 1)) +[GOOD] (define-fun s22 () ADT ((as AInteger ADT) 3)) [GOOD] (define-fun s23 () Bool (= s0 s22)) [GOOD] (define-fun s24 () Bool (not s23)) [GOOD] (assert s24) @@ -168,13 +168,13 @@ *** Exit code: ExitSuccess MODEL:Satisfiable. Model: + a = AInteger 3 :: ADT +MODEL:Satisfiable. Model: a = AInteger 1 :: ADT MODEL:Satisfiable. Model: a = AInteger 2 :: ADT MODEL:Satisfiable. Model: a = AInteger 5 :: ADT -MODEL:Satisfiable. Model: - a = AInteger 3 :: ADT MODEL:Satisfiable. Model: a = AInteger 0 :: ADT MODEL:Satisfiable. Model: diff --git a/SBVTestSuite/GoldFiles/adt05.gold b/SBVTestSuite/GoldFiles/adt05.gold --- a/SBVTestSuite/GoldFiles/adt05.gold +++ b/SBVTestSuite/GoldFiles/adt05.gold @@ -1,10 +1,14 @@ -** Calling: cvc5 --lang smt --incremental --nl-cov +** 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 HO_ALL) ; has unbounded values, using catch-all. +[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] ; --- tuples --- [GOOD] (declare-datatypes ((SBVTuple2 2)) ((par (T1 T2) ((mkSBVTuple2 (proj_1_SBVTuple2 T1) @@ -84,11 +88,11 @@ [GOOD] ; --- uninterpreted constants --- [GOOD] ; --- user defined functions --- [GOOD] ; --- assignments --- -[GOOD] (define-fun s2 () Bool (is-AFloat s0)) +[GOOD] (define-fun s2 () Bool ((as is-AFloat Bool) s0)) [GOOD] (define-fun s3 () (_ FloatingPoint 8 24) (getAFloat_1 s0)) [GOOD] (define-fun s5 () Bool (fp.eq s3 s4)) [GOOD] (define-fun s6 () Bool (and s2 s5)) -[GOOD] (define-fun s7 () Bool (is-AFloat s1)) +[GOOD] (define-fun s7 () Bool ((as is-AFloat Bool) s1)) [GOOD] (define-fun s8 () (_ FloatingPoint 8 24) (getAFloat_1 s1)) [GOOD] (define-fun s9 () Bool (fp.isNaN s8)) [GOOD] (define-fun s10 () Bool (and s7 s9)) @@ -101,9 +105,9 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (s0)) -[RECV] ((s0 (AFloat (fp #b0 #b10000001 #b00000000000000000000000)))) +[RECV] ((s0 (AFloat (fp #b0 #x81 #b00000000000000000000000)))) [SEND] (get-value (s1)) -[RECV] ((s1 (AFloat (fp #b0 #b11111111 #b10000000000000000000000)))) +[RECV] ((s1 (AFloat (_ NaN 8 24)))) [GOOD] (push 1) [GOOD] (define-fun s11 () ADT ((as AFloat ADT) (fp #b0 #b10000001 #b00000000000000000000000))) [GOOD] (define-fun s12 () Bool (= s0 s11)) @@ -123,7 +127,7 @@ [SEND] (check-sat) [RECV] unsat [GOOD] (pop 1) -*** Solver : CVC5 +*** Solver : Z3 *** Exit code: ExitSuccess MODEL:Satisfiable. Model: diff --git a/SBVTestSuite/GoldFiles/adt06.gold b/SBVTestSuite/GoldFiles/adt06.gold --- a/SBVTestSuite/GoldFiles/adt06.gold +++ b/SBVTestSuite/GoldFiles/adt06.gold @@ -94,11 +94,10 @@ [RECV] sat [SEND] (get-value (s0)) [RECV] ((s0 (AMaybe (Just (mkSBVTuple3 2.0 - (fp #b0 #x00 #b00000000000000000000001) - (mkSBVTuple2 (Right (fp #b0 #x00 #b00000000000000000100000)) - (seq.unit false))))))) + (_ +zero 8 24) + (mkSBVTuple2 (Right (_ +zero 8 24)) (seq.unit true))))))) -getValue: AMaybe (Just (2.0,1.0e-45,(Right 4.5e-44,[False]))) +getValue: AMaybe (Just (2.0,0.0,(Right 0.0,[True]))) DONE *** Solver : Z3 *** Exit code: ExitSuccess diff --git a/SBVTestSuite/GoldFiles/adt_gen00.gold b/SBVTestSuite/GoldFiles/adt_gen00.gold --- a/SBVTestSuite/GoldFiles/adt_gen00.gold +++ b/SBVTestSuite/GoldFiles/adt_gen00.gold @@ -267,12 +267,11 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (s0)) -[RECV] ((s0 (Let "p" - (Add (Mul (Val 4) (Mul (Val (- 5)) (Val (- 3)))) - (Let "d" (Val (- 58)) (Var "d"))) - (Let "d" (Add (Val 8) (Val 1)) (Add (Var "d") (Val 3)))))) +[RECV] ((s0 (Let "a" + (Add (Val 0) (Let "a" (Val 5) (Val 1142))) + (Let "a" (Val 4) (Add (Val 281) (Val (- 269))))))) -Got: (let p = ((4 * (-5 * -3)) + (let d = -58 in d)) in (let d = (8 + 1) in (d + 3))) +Got: (let a = (0 + (let a = 5 in 1142)) in (let a = 4 in (281 + -269))) DONE *** Solver : Z3 *** Exit code: ExitSuccess diff --git a/SBVTestSuite/GoldFiles/adt_mr00.gold b/SBVTestSuite/GoldFiles/adt_mr00.gold --- a/SBVTestSuite/GoldFiles/adt_mr00.gold +++ b/SBVTestSuite/GoldFiles/adt_mr00.gold @@ -54,16 +54,15 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (s0)) -[RECV] ((s0 (Seq (Assign "!3!" (Var "!6!")) - (Seq (Assign "!5!" (Var "!8!")) - (Seq (Assign "!4!" (Var "!7!")) - (Assign "!0!" (Add (Var "!1!") (Var "!2!")))))))) +[RECV] ((s0 (Seq (Assign "!2!" (Con 3)) + (Seq (Assign "!4!" (Con 5)) + (Seq (Assign "!3!" (Con 4)) (Assign "!0!" (Add (Var "!1!") (Con 2)))))))) Got: -!3! := !6!; -!5! := !8!; -!4! := !7!; -!0! := (!1! + !2!) +!2! := 3; +!4! := 5; +!3! := 4; +!0! := (!1! + 2) DONE *** Solver : Z3 *** Exit code: ExitSuccess diff --git a/SBVTestSuite/GoldFiles/adt_mr04.gold b/SBVTestSuite/GoldFiles/adt_mr04.gold --- a/SBVTestSuite/GoldFiles/adt_mr04.gold +++ b/SBVTestSuite/GoldFiles/adt_mr04.gold @@ -42,10 +42,10 @@ [RECV] sat [SEND] (get-value (s0)) [RECV] ((s0 ((as A2 (A Int (A (_ FloatingPoint 8 24) Bool))) (A3 (Aab "!0!" - (Aab (_ +zero 8 24) false)))))) + (Aa (fp #b0 #x00 #b00001000000000000000000))))))) Got: -A2 {a2 = A3 {a3 = Aab {aba = "!0!", abb = Aab {aba = 0.0, abb = False}}}} +A2 {a2 = A3 {a3 = Aab {aba = "!0!", abb = Aa {aa = 3.67342e-40}}}} DONE *** Solver : Z3 *** Exit code: ExitSuccess diff --git a/SBVTestSuite/GoldFiles/adt_pgen00.gold b/SBVTestSuite/GoldFiles/adt_pgen00.gold --- a/SBVTestSuite/GoldFiles/adt_pgen00.gold +++ b/SBVTestSuite/GoldFiles/adt_pgen00.gold @@ -268,17 +268,10 @@ [RECV] sat [SEND] (get-value (s0)) [RECV] ((s0 (Let "a" - (Let "t" (Val (- 3)) (Var "t")) - (Let "k" - (Mul (Val 7) (Var "a")) - (Add (Val 12) - (Mul (Mul (Val 4) (Val 3)) - (Mul (Var "k") - (Mul (Val 5) - (Add (Add (Val 6) (Var "k")) - (Let "l" (Var "k") (Val 15))))))))))) + (Val 3) + (Let "d" (Val 12) (Add (Mul (Val 0) (Add (Val 0) (Var "d"))) (Var "d")))))) -Got: (let a = (let t = -3 in t) in (let k = (7 * a) in (12 + ((4 * 3) * (k * (5 * ((6 + k) + (let l = k in 15)))))))) +Got: (let a = 3 in (let d = 12 in ((0 * (0 + d)) + d))) DONE *** Solver : Z3 *** Exit code: ExitSuccess diff --git a/SBVTestSuite/GoldFiles/allSat7.gold b/SBVTestSuite/GoldFiles/allSat7.gold --- a/SBVTestSuite/GoldFiles/allSat7.gold +++ b/SBVTestSuite/GoldFiles/allSat7.gold @@ -578,33879 +578,33879 @@ [SEND] (get-value (s1)) [RECV] ((s1 2)) [SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 42 -[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 s61) -Fast allSat, Looking for solution 43 -[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 s60) -Fast allSat, Looking for solution 44 -[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 s63) -Fast allSat, Looking for solution 45 -[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 s64) -Fast allSat, Looking for solution 46 -[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 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 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 48 -[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 s67) -Fast allSat, Looking for solution 49 -[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 s68) -Fast allSat, Looking for solution 50 -[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 s69) -Fast allSat, Looking for solution 51 -[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 s70) -Fast allSat, Looking for solution 52 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -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 s58) -[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 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 54 -[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 s67) -Fast allSat, Looking for solution 55 -[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 s66) -Fast allSat, Looking for solution 56 -[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 s65) -Fast allSat, Looking for solution 57 -[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 s64) -Fast allSat, Looking for solution 58 -[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 s63) -Fast allSat, Looking for solution 59 -[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 s62) -Fast allSat, Looking for solution 60 -[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 s61) -Fast allSat, Looking for solution 61 -[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 s69) -Fast allSat, Looking for solution 62 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 63 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 64 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -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 s60) -[GOOD] (define-fun s75 () Bool (= s1 s20)) -[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 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 66 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 67 -[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 s62) -Fast allSat, Looking for solution 68 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 69 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 70 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[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 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 72 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 73 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 74 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 75 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 76 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 77 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s61) -[GOOD] (define-fun s76 () Bool (= s1 s22)) -[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 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 78 -[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 s67) -Fast allSat, Looking for solution 79 -[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 s68) -Fast allSat, Looking for solution 80 -[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 s69) -Fast allSat, Looking for solution 81 -[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 s70) -Fast allSat, Looking for solution 82 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 83 -[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 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 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 85 -[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 s63) -Fast allSat, Looking for solution 86 -[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 s60) -Fast allSat, Looking for solution 87 -[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 s58) -Fast allSat, Looking for solution 88 -[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 s72) -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 s62) -[GOOD] (define-fun s77 () Bool (= s1 s24)) -[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 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 90 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 91 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 92 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 93 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 94 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 95 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 96 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 97 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 98 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 99 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 100 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 101 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s63) -[GOOD] (define-fun s78 () Bool (= s1 s26)) -[GOOD] (assert s78) -Fast allSat, Looking for solution 101 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 102 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 103 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 104 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 105 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 106 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 107 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[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 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 109 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 110 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 111 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 112 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 113 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s64) -[GOOD] (define-fun s79 () Bool (= s1 s28)) -[GOOD] (assert s79) -Fast allSat, Looking for solution 113 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 114 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 115 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 116 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 117 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 118 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 119 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 120 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 121 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 122 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 123 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 124 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 125 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s65) -[GOOD] (define-fun s80 () Bool (= s1 s30)) -[GOOD] (assert s80) -Fast allSat, Looking for solution 125 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 126 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 127 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 128 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 129 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 130 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 131 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 132 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 133 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 134 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 135 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 136 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 137 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s66) -[GOOD] (define-fun s81 () Bool (= s1 s32)) -[GOOD] (assert s81) -Fast allSat, Looking for solution 137 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 138 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 139 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 140 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 141 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 142 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 143 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 144 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 145 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 146 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 147 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 148 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 149 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s67) -[GOOD] (define-fun s82 () Bool (= s1 s34)) -[GOOD] (assert s82) -Fast allSat, Looking for solution 149 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 150 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 151 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 152 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 153 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 154 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 155 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 156 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 157 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 158 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 159 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 160 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 161 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s68) -[GOOD] (define-fun s83 () Bool (= s1 s36)) -[GOOD] (assert s83) -Fast allSat, Looking for solution 161 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 162 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 163 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 164 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 165 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 166 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 167 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 168 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 169 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 170 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 171 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 172 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 173 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s69) -[GOOD] (define-fun s84 () Bool (= s1 s38)) -[GOOD] (assert s84) -Fast allSat, Looking for solution 173 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 174 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 175 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 176 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 177 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 178 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 179 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 180 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 181 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 182 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 183 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 184 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 185 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s70) -[GOOD] (assert s44) -[GOOD] (define-fun s85 () Bool (= s1 s40)) -[GOOD] (assert s85) -Fast allSat, Looking for solution 185 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 186 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 187 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 188 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 189 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 190 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 191 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 192 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 193 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 194 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 195 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 196 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 15)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 197 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (define-fun s86 () Bool (distinct s1 s5)) -[GOOD] (assert s86) -[GOOD] (define-fun s87 () Bool (= s0 s40)) -[GOOD] (assert s87) -Fast allSat, Looking for solution 197 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s45) -Fast allSat, Looking for solution 198 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s46) -Fast allSat, Looking for solution 199 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s47) -Fast allSat, Looking for solution 200 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s48) -Fast allSat, Looking for solution 201 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s49) -Fast allSat, Looking for solution 202 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s50) -Fast allSat, Looking for solution 203 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s51) -Fast allSat, Looking for solution 204 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s52) -Fast allSat, Looking for solution 205 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s53) -Fast allSat, Looking for solution 206 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s54) -Fast allSat, Looking for solution 207 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s55) -Fast allSat, Looking for solution 208 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s56) -Fast allSat, Looking for solution 209 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s57) -Fast allSat, Looking for solution 210 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s58) -[GOOD] (assert s59) -Fast allSat, Looking for solution 210 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[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 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[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 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[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 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[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 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[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 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 216 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[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 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[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 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[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 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[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 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[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 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 s72) -[GOOD] (assert s73) -Fast allSat, Looking for solution 222 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 223 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 224 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 225 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 226 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 227 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 228 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[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 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 230 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 231 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 232 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 233 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 234 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s58) -[GOOD] (assert s74) -Fast allSat, Looking for solution 234 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 235 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 236 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 237 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 238 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[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 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 240 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 241 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 242 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 243 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 244 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 245 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 246 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s60) -[GOOD] (assert s75) -Fast allSat, Looking for solution 246 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 247 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 248 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 249 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 250 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 251 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 252 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 253 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 254 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 255 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 256 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 257 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 258 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s61) -[GOOD] (assert s76) -Fast allSat, Looking for solution 258 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 259 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 260 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 261 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 262 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 263 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 264 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 265 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 266 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 267 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[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 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[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 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 270 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s62) -[GOOD] (assert s77) -Fast allSat, Looking for solution 270 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 271 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[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 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 273 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[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 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 275 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 276 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 277 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 278 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 279 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 280 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 281 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 282 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s63) -[GOOD] (assert s78) -Fast allSat, Looking for solution 282 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 283 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 284 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 285 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[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 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 287 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 288 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 289 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[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 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[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 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[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 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[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 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 294 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s64) -[GOOD] (assert s79) -Fast allSat, Looking for solution 294 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 295 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[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 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[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 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 298 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[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 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[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 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 301 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 302 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 303 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 304 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 305 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 306 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert 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 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 307 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 308 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[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 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 310 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 311 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 312 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[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 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[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 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[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 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[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 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[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 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 318 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s66) -[GOOD] (assert s81) -Fast allSat, Looking for solution 318 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 319 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[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 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[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 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[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 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 323 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 324 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 325 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 326 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 327 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 328 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 329 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 330 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s67) -[GOOD] (assert s82) -Fast allSat, Looking for solution 330 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 331 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[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 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 333 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 334 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 335 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 336 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 337 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 338 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[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 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[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 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[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 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 342 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s68) -[GOOD] (assert s83) -Fast allSat, Looking for solution 342 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 343 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[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 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[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 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 346 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 347 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 348 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 349 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 350 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 351 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 352 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 353 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 354 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s69) -[GOOD] (assert s84) -Fast allSat, Looking for solution 354 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 355 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 356 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 357 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 358 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 359 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 360 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 361 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 362 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 363 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 364 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[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 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 366 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s70) -[GOOD] (assert s87) -[GOOD] (define-fun s89 () Bool (= s1 s5)) -[GOOD] (assert s89) -Fast allSat, Looking for solution 366 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 367 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 368 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 369 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 370 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 371 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 372 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 373 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 374 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 375 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 376 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 377 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 14)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 378 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s43) -[GOOD] (define-fun s90 () Bool (= s0 s38)) -[GOOD] (assert s90) -Fast allSat, Looking for solution 378 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s86) -Fast allSat, Looking for solution 379 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s46) -Fast allSat, Looking for solution 380 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s47) -Fast allSat, Looking for solution 381 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s48) -Fast allSat, Looking for solution 382 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s49) -Fast allSat, Looking for solution 383 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s50) -Fast allSat, Looking for solution 384 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s51) -Fast allSat, Looking for solution 385 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s52) -Fast allSat, Looking for solution 386 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s53) -Fast allSat, Looking for solution 387 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s54) -Fast allSat, Looking for solution 388 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s55) -Fast allSat, Looking for solution 389 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s56) -Fast allSat, Looking for solution 390 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s57) -Fast allSat, Looking for solution 391 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s71) -[GOOD] (assert s59) -Fast allSat, Looking for solution 391 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -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 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -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 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -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 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -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 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 396 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 397 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -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 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -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 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -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 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -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 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -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 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 403 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s72) -[GOOD] (assert s73) -Fast allSat, Looking for solution 403 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 404 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 405 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 406 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 407 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 408 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 409 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 410 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 411 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 412 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 413 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 414 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 415 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s58) -[GOOD] (assert s74) -Fast allSat, Looking for solution 415 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 416 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 417 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 418 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 419 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 420 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 421 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 422 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 423 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 424 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 425 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 426 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 427 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s60) -[GOOD] (assert s75) -Fast allSat, Looking for solution 427 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 428 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 429 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 430 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 431 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 432 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 433 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 434 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 435 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 436 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 437 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 438 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -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 s61) -[GOOD] (assert s76) -Fast allSat, Looking for solution 439 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 440 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 441 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 442 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 443 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 444 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 445 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 446 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 447 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 448 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 449 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 450 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -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 s62) -[GOOD] (assert s77) -Fast allSat, Looking for solution 451 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 452 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 453 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 454 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 455 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 456 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 457 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 458 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 459 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 460 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 461 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 462 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -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 s63) -[GOOD] (assert s78) -Fast allSat, Looking for solution 463 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 464 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 465 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 466 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 467 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 468 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 469 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 470 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[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 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[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 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[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 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 474 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -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 s63) -[GOOD] (assert s79) -Fast allSat, Looking for solution 475 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 476 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 477 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 478 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 479 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 480 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 481 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 482 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 483 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 484 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 485 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 486 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -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 s63) -[GOOD] (assert s80) -Fast allSat, Looking for solution 487 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 488 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 489 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 490 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 491 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 492 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 493 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 494 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[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 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[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 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[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 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 498 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -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 s63) -[GOOD] (assert s81) -Fast allSat, Looking for solution 499 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 500 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 501 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 502 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 503 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 504 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 505 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 506 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[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 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[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 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[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 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 510 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -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 s63) -[GOOD] (assert s82) -Fast allSat, Looking for solution 511 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 512 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 513 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 514 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 515 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 516 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 517 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 518 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[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 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[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 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[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 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 522 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -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 s83) -Fast allSat, Looking for solution 523 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 524 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 525 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 526 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 527 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 528 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 529 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 530 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 531 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[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 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[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 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 534 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -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 s63) -[GOOD] (assert s89) -Fast allSat, Looking for solution 535 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 536 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 537 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 538 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 539 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 540 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 541 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 542 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 543 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 544 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[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 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 546 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 547 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s88) -[GOOD] (assert s90) -[GOOD] (assert s85) -Fast allSat, Looking for solution 547 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 548 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 549 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 550 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 551 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 552 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 553 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 554 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 555 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 556 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 557 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 558 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 13)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 559 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s45) -[GOOD] (define-fun s91 () Bool (= s0 s36)) -[GOOD] (assert s91) -Fast allSat, Looking for solution 559 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s43) -Fast allSat, Looking for solution 560 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s86) -Fast allSat, Looking for solution 561 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s47) -Fast allSat, Looking for solution 562 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s48) -Fast allSat, Looking for solution 563 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s49) -Fast allSat, Looking for solution 564 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s50) -Fast allSat, Looking for solution 565 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s51) -Fast allSat, Looking for solution 566 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s52) -Fast allSat, Looking for solution 567 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s53) -Fast allSat, Looking for solution 568 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s54) -Fast allSat, Looking for solution 569 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s55) -Fast allSat, Looking for solution 570 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s56) -Fast allSat, Looking for solution 571 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s57) -Fast allSat, Looking for solution 572 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s58) -[GOOD] (assert s59) -Fast allSat, Looking for solution 572 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 573 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 574 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 575 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 576 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 577 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 578 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 579 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 580 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 581 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 582 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 583 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 584 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s72) -[GOOD] (assert s73) -Fast allSat, Looking for solution 584 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 585 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 586 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 587 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 588 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 589 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 590 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 591 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 592 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 593 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 594 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 595 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 596 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s58) -[GOOD] (assert s74) -Fast allSat, Looking for solution 596 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 597 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 598 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 599 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 600 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 601 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 602 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 603 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 604 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 605 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 606 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 607 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 608 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s60) -[GOOD] (assert s75) -Fast allSat, Looking for solution 608 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 609 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 610 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 611 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 612 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 613 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 614 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 615 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 616 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 617 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 618 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 619 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 620 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s61) -[GOOD] (assert s76) -Fast allSat, Looking for solution 620 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 621 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 622 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 623 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 624 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 625 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 626 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 627 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 628 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 629 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 630 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 631 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 632 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s62) -[GOOD] (assert s77) -Fast allSat, Looking for solution 632 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 633 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 634 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 635 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 636 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 637 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 638 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 639 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 640 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 641 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 642 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 643 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 644 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s63) -[GOOD] (assert s78) -Fast allSat, Looking for solution 644 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 645 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 646 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 647 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 648 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 649 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 650 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 651 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 652 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 653 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 654 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 655 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 656 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s64) -[GOOD] (assert s79) -Fast allSat, Looking for solution 656 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 657 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 658 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 659 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 660 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 661 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 662 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 663 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 664 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 665 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 666 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 667 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 668 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s65) -[GOOD] (assert s80) -Fast allSat, Looking for solution 668 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 669 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 670 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 671 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 672 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 673 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 674 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 675 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 676 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 677 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 678 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 679 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 680 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s66) -[GOOD] (assert s81) -Fast allSat, Looking for solution 680 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 681 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 682 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 683 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 684 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 685 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 686 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 687 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 688 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 689 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 690 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 691 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 692 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s67) -[GOOD] (assert s82) -Fast allSat, Looking for solution 692 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 693 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 694 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 695 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 696 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 697 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 698 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 699 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 700 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 701 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 702 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 703 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 704 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s68) -[GOOD] (assert s89) -Fast allSat, Looking for solution 704 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 705 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 706 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 707 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 708 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 709 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 710 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 711 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 712 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 713 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 714 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 715 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 716 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s68) -[GOOD] (assert s85) -Fast allSat, Looking for solution 716 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 717 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 718 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 719 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[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 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 721 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 722 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 723 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 724 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[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 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 726 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[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 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[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 s71) -[GOOD] (assert s91) -[GOOD] (assert s84) -Fast allSat, Looking for solution 728 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 729 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 730 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 731 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 732 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 733 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 734 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 735 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 736 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 737 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 738 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 739 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 12)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 740 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s46) -[GOOD] (define-fun s92 () Bool (= s0 s34)) -[GOOD] (assert s92) -Fast allSat, Looking for solution 740 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s45) -Fast allSat, Looking for solution 741 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s43) -Fast allSat, Looking for solution 742 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s48) -Fast allSat, Looking for solution 743 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s49) -Fast allSat, Looking for solution 744 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s50) -Fast allSat, Looking for solution 745 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s51) -Fast allSat, Looking for solution 746 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s52) -Fast allSat, Looking for solution 747 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s53) -Fast allSat, Looking for solution 748 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s54) -Fast allSat, Looking for solution 749 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s55) -Fast allSat, Looking for solution 750 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s56) -Fast allSat, Looking for solution 751 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s57) -Fast allSat, Looking for solution 752 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s86) -Fast allSat, Looking for solution 753 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s71) -[GOOD] (assert s89) -Fast allSat, Looking for solution 753 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 754 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 755 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 756 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 757 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 758 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 759 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 760 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 761 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 762 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 763 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 764 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 765 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s69) -[GOOD] (assert s59) -Fast allSat, Looking for solution 765 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 766 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 767 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 768 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 769 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 770 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 771 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 772 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 773 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 774 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 775 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 776 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 777 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s69) -[GOOD] (assert s73) -Fast allSat, Looking for solution 777 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 778 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[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 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 780 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 781 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 782 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 783 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 784 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 785 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 786 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 787 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 788 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 789 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s69) -[GOOD] (assert s74) -Fast allSat, Looking for solution 789 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 790 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 791 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 792 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 793 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 794 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 795 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 796 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 797 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 798 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 799 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 800 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 801 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s69) -[GOOD] (assert s75) -Fast allSat, Looking for solution 801 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[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 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[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 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 804 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 805 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 806 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 807 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 808 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 809 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 810 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 811 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 812 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 813 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s69) -[GOOD] (assert s76) -Fast allSat, Looking for solution 813 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 814 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 815 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 816 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 817 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 818 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 819 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 820 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 821 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 822 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 823 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 824 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 825 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s69) -[GOOD] (assert s77) -Fast allSat, Looking for solution 825 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 826 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 827 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 828 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 829 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 830 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 831 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 832 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 833 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 834 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 835 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 836 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 837 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s69) -[GOOD] (assert s78) -Fast allSat, Looking for solution 837 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 838 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 839 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 840 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 841 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 842 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 843 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 844 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 845 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 846 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 847 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 848 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 849 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s69) -[GOOD] (assert s79) -Fast allSat, Looking for solution 849 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 850 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 851 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 852 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 853 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 854 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 855 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 856 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 857 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 858 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 859 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 860 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 861 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s69) -[GOOD] (assert s80) -Fast allSat, Looking for solution 861 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 862 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 863 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 864 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 865 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 866 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 867 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 868 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 869 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 870 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 871 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 872 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 873 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s69) -[GOOD] (assert s81) -Fast allSat, Looking for solution 873 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 874 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 875 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 876 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 877 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 878 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 879 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 880 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 881 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 882 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 883 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 884 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 885 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s88) -[GOOD] (assert s85) -Fast allSat, Looking for solution 885 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 886 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 887 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 888 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 889 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 890 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 891 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 892 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 893 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 894 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 895 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 896 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 897 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s71) -[GOOD] (assert s84) -Fast allSat, Looking for solution 897 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 898 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 899 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 900 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 901 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 902 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 903 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 904 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 905 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 906 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 907 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 908 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 909 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s70) -[GOOD] (assert s92) -[GOOD] (assert s83) -Fast allSat, Looking for solution 909 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 910 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 911 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 912 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 913 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 914 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 915 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 916 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 917 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 918 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 919 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 920 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 11)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 921 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s47) -[GOOD] (define-fun s93 () Bool (= s0 s32)) -[GOOD] (assert s93) -Fast allSat, Looking for solution 921 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s46) -Fast allSat, Looking for solution 922 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s45) -Fast allSat, Looking for solution 923 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s43) -Fast allSat, Looking for solution 924 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s49) -Fast allSat, Looking for solution 925 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s50) -Fast allSat, Looking for solution 926 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s51) -Fast allSat, Looking for solution 927 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s52) -Fast allSat, Looking for solution 928 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s53) -Fast allSat, Looking for solution 929 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s54) -Fast allSat, Looking for solution 930 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s55) -Fast allSat, Looking for solution 931 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s56) -Fast allSat, Looking for solution 932 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s57) -Fast allSat, Looking for solution 933 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s86) -Fast allSat, Looking for solution 934 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s71) -[GOOD] (assert s89) -Fast allSat, Looking for solution 934 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -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 s69) -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 s68) -Fast allSat, Looking for solution 937 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 938 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 939 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 940 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 941 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 942 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 943 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 944 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 945 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 946 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s68) -[GOOD] (assert s59) -Fast allSat, Looking for solution 946 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 947 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 948 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 949 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 950 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 951 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 952 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 953 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 954 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 955 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 956 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 957 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 958 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s68) -[GOOD] (assert s73) -Fast allSat, Looking for solution 958 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 959 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[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 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 961 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 962 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 963 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 964 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 965 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 966 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 967 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 968 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 969 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 970 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s68) -[GOOD] (assert s74) -Fast allSat, Looking for solution 970 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 971 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 972 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 973 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 974 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 975 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 976 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 977 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 978 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 979 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 980 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 981 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 982 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s68) -[GOOD] (assert s75) -Fast allSat, Looking for solution 982 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 983 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 984 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 985 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 986 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 987 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 988 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 989 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 990 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 991 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 992 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 993 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 994 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s68) -[GOOD] (assert s76) -Fast allSat, Looking for solution 994 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 995 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 996 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 997 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 998 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 999 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1000 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1001 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1002 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1003 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1004 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1005 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1006 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s68) -[GOOD] (assert s77) -Fast allSat, Looking for solution 1006 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1007 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1008 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1009 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 1010 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1011 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1012 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1013 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1014 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1015 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1016 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1017 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1018 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s68) -[GOOD] (assert s78) -Fast allSat, Looking for solution 1018 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1019 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1020 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1021 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 1022 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1023 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1024 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1025 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1026 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1027 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1028 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1029 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1030 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s68) -[GOOD] (assert s79) -Fast allSat, Looking for solution 1030 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1031 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1032 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1033 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 1034 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1035 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1036 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1037 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1038 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1039 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1040 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1041 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1042 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s68) -[GOOD] (assert s80) -Fast allSat, Looking for solution 1042 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1043 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1044 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1045 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 1046 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1047 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1048 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1049 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1050 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1051 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1052 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1053 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1054 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s88) -[GOOD] (assert s85) -Fast allSat, Looking for solution 1054 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1055 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1056 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1057 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1058 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1059 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1060 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1061 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1062 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1063 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1064 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1065 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1066 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s71) -[GOOD] (assert s84) -Fast allSat, Looking for solution 1066 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 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 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1068 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1069 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1070 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1071 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[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 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1073 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1074 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1075 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1076 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1077 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -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 s70) -[GOOD] (assert s83) -Fast allSat, Looking for solution 1078 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[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 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 1080 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1081 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1082 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1083 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1084 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1085 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1086 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1087 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1088 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1089 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1090 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s69) -[GOOD] (assert s93) -[GOOD] (assert s82) -Fast allSat, Looking for solution 1090 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1091 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1092 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 1093 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1094 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1095 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1096 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1097 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1098 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1099 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1100 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1101 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 10)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1102 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s48) -[GOOD] (define-fun s94 () Bool (= s0 s30)) -[GOOD] (assert s94) -Fast allSat, Looking for solution 1102 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s47) -Fast allSat, Looking for solution 1103 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s46) -Fast allSat, Looking for solution 1104 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s45) -Fast allSat, Looking for solution 1105 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s43) -Fast allSat, Looking for solution 1106 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s50) -Fast allSat, Looking for solution 1107 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s51) -Fast allSat, Looking for solution 1108 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s52) -Fast allSat, Looking for solution 1109 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s53) -Fast allSat, Looking for solution 1110 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s54) -Fast allSat, Looking for solution 1111 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s55) -Fast allSat, Looking for solution 1112 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s56) -Fast allSat, Looking for solution 1113 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s57) -Fast allSat, Looking for solution 1114 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s86) -Fast allSat, Looking for solution 1115 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s71) -[GOOD] (assert s89) -Fast allSat, Looking for solution 1115 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1116 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1117 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1118 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1119 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1120 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1121 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1122 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1123 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1124 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1125 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1126 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1127 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s67) -[GOOD] (assert s59) -Fast allSat, Looking for solution 1127 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1128 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1129 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1130 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1131 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1132 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1133 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1134 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1135 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1136 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1137 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1138 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 1139 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s67) -[GOOD] (assert s73) -Fast allSat, Looking for solution 1139 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1140 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1141 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1142 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1143 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 1144 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1145 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1146 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1147 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1148 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1149 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1150 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1151 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s67) -[GOOD] (assert s74) -Fast allSat, Looking for solution 1151 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1152 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1153 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1154 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1155 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 1156 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[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 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1158 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1159 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1160 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1161 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1162 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1163 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s67) -[GOOD] (assert s75) -Fast allSat, Looking for solution 1163 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1164 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1165 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1166 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1167 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 1168 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1169 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1170 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1171 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1172 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1173 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1174 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1175 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s67) -[GOOD] (assert s76) -Fast allSat, Looking for solution 1175 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1176 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1177 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1178 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1179 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 1180 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1181 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1182 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1183 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1184 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1185 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1186 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1187 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s67) -[GOOD] (assert s77) -Fast allSat, Looking for solution 1187 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1188 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1189 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1190 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1191 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 1192 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1193 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1194 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1195 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1196 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1197 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1198 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1199 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s67) -[GOOD] (assert s78) -Fast allSat, Looking for solution 1199 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1200 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1201 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1202 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1203 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 1204 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1205 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1206 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1207 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1208 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1209 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1210 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1211 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s67) -[GOOD] (assert s79) -Fast allSat, Looking for solution 1211 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[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 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1213 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1214 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1215 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 1216 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1217 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1218 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1219 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1220 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1221 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1222 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1223 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s88) -[GOOD] (assert s85) -Fast allSat, Looking for solution 1223 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1224 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1225 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1226 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1227 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1228 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1229 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1230 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1231 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1232 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1233 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1234 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1235 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s71) -[GOOD] (assert s84) -Fast allSat, Looking for solution 1235 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 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 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1237 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1238 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1239 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1240 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1241 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1242 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1243 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1244 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1245 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1246 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1247 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s71) -[GOOD] (assert s83) -Fast allSat, Looking for solution 1247 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1248 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 1249 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1250 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1251 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1252 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1253 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1254 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1255 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1256 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1257 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1258 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1259 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s71) -[GOOD] (assert s82) -Fast allSat, Looking for solution 1259 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1260 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1261 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 1262 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1263 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1264 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1265 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1266 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1267 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1268 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1269 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1270 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1271 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s68) -[GOOD] (assert s94) -[GOOD] (assert s81) -Fast allSat, Looking for solution 1271 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1272 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[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 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1274 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 1275 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1276 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1277 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1278 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1279 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1280 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1281 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1282 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 9)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1283 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s49) -[GOOD] (define-fun s95 () Bool (= s0 s28)) -[GOOD] (assert s95) -Fast allSat, Looking for solution 1283 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s48) -Fast allSat, Looking for solution 1284 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s47) -Fast allSat, Looking for solution 1285 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s46) -Fast allSat, Looking for solution 1286 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s45) -Fast allSat, Looking for solution 1287 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s43) -Fast allSat, Looking for solution 1288 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s86) -Fast allSat, Looking for solution 1289 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s51) -Fast allSat, Looking for solution 1290 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s52) -Fast allSat, Looking for solution 1291 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s53) -Fast allSat, Looking for solution 1292 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s54) -Fast allSat, Looking for solution 1293 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s55) -Fast allSat, Looking for solution 1294 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s56) -Fast allSat, Looking for solution 1295 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s57) -Fast allSat, Looking for solution 1296 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s58) -[GOOD] (assert s59) -Fast allSat, Looking for solution 1296 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1297 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1298 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1299 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1300 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1301 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1302 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1303 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1304 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1305 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1306 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1307 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 1308 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s72) -[GOOD] (assert s73) -Fast allSat, Looking for solution 1308 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1309 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[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 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1311 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1312 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1313 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1314 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 1315 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1316 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1317 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1318 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1319 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1320 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s58) -[GOOD] (assert s74) -Fast allSat, Looking for solution 1320 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1321 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1322 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1323 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1324 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1325 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1326 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 1327 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1328 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1329 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1330 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1331 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1332 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s60) -[GOOD] (assert s75) -Fast allSat, Looking for solution 1332 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1333 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1334 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1335 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1336 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1337 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1338 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 1339 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1340 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1341 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1342 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1343 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1344 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s61) -[GOOD] (assert s76) -Fast allSat, Looking for solution 1344 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1345 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1346 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1347 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1348 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1349 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1350 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 1351 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[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 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1353 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[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 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[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 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[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 s62) -[GOOD] (assert s77) -Fast allSat, Looking for solution 1356 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1357 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1358 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1359 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1360 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1361 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1362 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 1363 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1364 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1365 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1366 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1367 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1368 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s63) -[GOOD] (assert s78) -Fast allSat, Looking for solution 1368 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1369 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1370 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1371 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1372 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1373 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1374 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 1375 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[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 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[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 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[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 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[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 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[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 s71) -[GOOD] (assert s89) -Fast allSat, Looking for solution 1380 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1381 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1382 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1383 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1384 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1385 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1386 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1387 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1388 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1389 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1390 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1391 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1392 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s88) -[GOOD] (assert s85) -Fast allSat, Looking for solution 1392 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1393 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1394 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1395 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1396 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1397 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1398 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[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 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[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 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[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 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[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 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[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 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[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 s71) -[GOOD] (assert s84) -Fast allSat, Looking for solution 1404 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1405 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1406 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1407 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1408 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1409 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[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 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1411 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1412 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1413 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1414 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1415 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -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 s70) -[GOOD] (assert s83) -Fast allSat, Looking for solution 1416 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -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 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -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 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -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 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -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 9)) -[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 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -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 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -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 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -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 s61) -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 s60) -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 s58) -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 s72) -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 s69) -[GOOD] (assert s82) -Fast allSat, Looking for solution 1428 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -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 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -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 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -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 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -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 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1433 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1434 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1435 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1436 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1437 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1438 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1439 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1440 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s68) -[GOOD] (assert s81) -Fast allSat, Looking for solution 1440 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1441 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1442 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1443 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -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 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -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 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -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 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -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 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -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 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -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 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -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 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -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 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1452 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s67) -[GOOD] (assert s95) -[GOOD] (assert s80) -Fast allSat, Looking for solution 1452 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1453 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1454 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1455 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1456 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 1457 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1458 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1459 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1460 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1461 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1462 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1463 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 8)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1464 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s50) -[GOOD] (define-fun s96 () Bool (= s0 s26)) -[GOOD] (assert s96) -Fast allSat, Looking for solution 1464 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s49) -Fast allSat, Looking for solution 1465 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s48) -Fast allSat, Looking for solution 1466 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s47) -Fast allSat, Looking for solution 1467 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s46) -Fast allSat, Looking for solution 1468 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s45) -Fast allSat, Looking for solution 1469 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s43) -Fast allSat, Looking for solution 1470 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s52) -Fast allSat, Looking for solution 1471 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s53) -Fast allSat, Looking for solution 1472 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s54) -Fast allSat, Looking for solution 1473 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s55) -Fast allSat, Looking for solution 1474 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s56) -Fast allSat, Looking for solution 1475 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s57) -Fast allSat, Looking for solution 1476 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s86) -Fast allSat, Looking for solution 1477 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s71) -[GOOD] (assert s89) -Fast allSat, Looking for solution 1477 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1478 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1479 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1480 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1481 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1482 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1483 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1484 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1485 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1486 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1487 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1488 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1489 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s65) -[GOOD] (assert s59) -Fast allSat, Looking for solution 1489 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1490 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1491 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1492 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1493 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1494 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1495 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1496 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1497 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1498 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1499 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1500 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 1501 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s65) -[GOOD] (assert s73) -Fast allSat, Looking for solution 1501 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1502 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1503 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1504 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1505 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1506 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1507 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 1508 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1509 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1510 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1511 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1512 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1513 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s65) -[GOOD] (assert s74) -Fast allSat, Looking for solution 1513 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1514 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1515 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1516 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1517 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1518 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1519 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 1520 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1521 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1522 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1523 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1524 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1525 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s65) -[GOOD] (assert s75) -Fast allSat, Looking for solution 1525 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1526 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1527 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1528 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1529 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1530 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1531 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 1532 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1533 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1534 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1535 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1536 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1537 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s65) -[GOOD] (assert s76) -Fast allSat, Looking for solution 1537 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[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 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1539 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1540 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1541 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1542 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1543 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 1544 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1545 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1546 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1547 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1548 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1549 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s65) -[GOOD] (assert s77) -Fast allSat, Looking for solution 1549 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1550 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1551 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1552 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1553 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1554 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1555 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 1556 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1557 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1558 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1559 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1560 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1561 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s88) -[GOOD] (assert s85) -Fast allSat, Looking for solution 1561 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[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 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1563 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1564 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1565 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1566 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1567 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1568 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1569 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1570 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1571 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1572 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1573 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s71) -[GOOD] (assert s84) -Fast allSat, Looking for solution 1573 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1574 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1575 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1576 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1577 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 1578 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1579 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1580 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1581 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1582 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1583 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1584 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1585 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s70) -[GOOD] (assert s83) -Fast allSat, Looking for solution 1585 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1586 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 1587 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1588 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1589 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1590 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1591 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[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 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1593 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1594 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1595 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1596 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1597 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s69) -[GOOD] (assert s82) -Fast allSat, Looking for solution 1597 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -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 s71) -Fast allSat, Looking for solution 1599 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1600 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -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 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -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 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -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 s63) -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 s62) -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 s61) -Fast allSat, Looking for solution 1606 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1607 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1608 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1609 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s68) -[GOOD] (assert s81) -Fast allSat, Looking for solution 1609 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -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 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -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 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -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 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -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 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -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 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -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 6)) -[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 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -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 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -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 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1619 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1620 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1621 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s67) -[GOOD] (assert s80) -Fast allSat, Looking for solution 1621 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -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 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -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 s70) -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 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -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 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -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 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -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 s63) -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 s62) -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 s61) -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 s60) -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 s58) -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 s72) -Fast allSat, Looking for solution 1633 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s66) -[GOOD] (assert s96) -[GOOD] (assert s79) -Fast allSat, Looking for solution 1633 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[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 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[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 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1636 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1637 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1638 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 1639 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1640 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1641 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1642 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1643 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1644 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 7)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1645 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s51) -[GOOD] (define-fun s97 () Bool (= s0 s24)) -[GOOD] (assert s97) -Fast allSat, Looking for solution 1645 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s50) -Fast allSat, Looking for solution 1646 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s49) -Fast allSat, Looking for solution 1647 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s53) -Fast allSat, Looking for solution 1648 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s48) -Fast allSat, Looking for solution 1649 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s54) -Fast allSat, Looking for solution 1650 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s47) -Fast allSat, Looking for solution 1651 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s55) -Fast allSat, Looking for solution 1652 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s46) -Fast allSat, Looking for solution 1653 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s56) -Fast allSat, Looking for solution 1654 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[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 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s57) -Fast allSat, Looking for solution 1656 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s43) -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 s86) -Fast allSat, Looking for solution 1658 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s71) -[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 s70) -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 s69) -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 s68) -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 s67) -Fast allSat, Looking for solution 1662 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -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 s65) -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 s64) -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 s62) -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 s61) -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 s60) -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 s58) -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 s72) -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 s85) -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 s64) -Fast allSat, Looking for solution 1671 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -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 s66) -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 s62) -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 s67) -Fast allSat, Looking for solution 1675 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -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 s68) -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 s60) -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 s69) -Fast allSat, Looking for solution 1679 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -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 s70) -Fast allSat, Looking for solution 1681 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -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 s64) -[GOOD] (assert s59) -Fast allSat, Looking for solution 1682 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1683 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1684 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1685 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1686 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1687 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1688 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1689 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1690 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1691 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1692 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1693 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 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 s71) -[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 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 1695 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1696 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1697 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1698 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1699 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1700 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1701 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1702 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1703 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1704 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1705 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 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 s64) -[GOOD] (assert s73) -Fast allSat, Looking for solution 1706 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1707 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1708 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1709 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1710 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1711 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1712 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1713 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 1714 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1715 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1716 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1717 -[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 s72) -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 s70) -[GOOD] (assert s83) -Fast allSat, Looking for solution 1718 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1719 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 1720 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1721 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1722 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1723 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1724 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1725 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1726 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1727 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1728 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1729 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 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 s64) -[GOOD] (assert s74) -Fast allSat, Looking for solution 1730 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1731 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1732 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1733 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1734 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1735 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1736 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1737 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 1738 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1739 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1740 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1741 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1742 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s69) -[GOOD] (assert s82) -Fast allSat, Looking for solution 1742 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1743 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1744 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 1745 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1746 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1747 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1748 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1749 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1750 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1751 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1752 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1753 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 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 s75) -Fast allSat, Looking for solution 1754 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1755 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1756 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1757 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1758 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1759 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1760 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1761 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 1762 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1763 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1764 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1765 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 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 s68) -[GOOD] (assert s81) -Fast allSat, Looking for solution 1766 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1767 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1768 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1769 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 1770 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1771 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1772 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1773 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1774 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1775 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1776 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1777 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 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 s64) -[GOOD] (assert s76) -Fast allSat, Looking for solution 1778 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1779 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1780 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1781 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1782 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1783 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1784 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1785 -[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 1786 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1787 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1788 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1789 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 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 s67) -[GOOD] (assert s80) -Fast allSat, Looking for solution 1790 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1791 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1792 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1793 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1794 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 1795 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1796 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1797 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert 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 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[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 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[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 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[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 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[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 s66) -[GOOD] (assert s79) -Fast allSat, Looking for solution 1802 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1803 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1804 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1805 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1806 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1807 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 1808 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[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 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1810 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1811 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1812 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1813 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1814 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s65) -[GOOD] (assert s97) -[GOOD] (assert s78) -Fast allSat, Looking for solution 1814 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1815 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1816 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1817 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1818 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1819 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1820 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 1821 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 1822 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1823 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1824 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1825 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 6)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1826 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s52) -[GOOD] (define-fun s98 () Bool (= s0 s22)) -[GOOD] (assert s98) -Fast allSat, Looking for solution 1826 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s51) -Fast allSat, Looking for solution 1827 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s50) -Fast allSat, Looking for solution 1828 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s49) -Fast allSat, Looking for solution 1829 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s48) -Fast allSat, Looking for solution 1830 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s47) -Fast allSat, Looking for solution 1831 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s46) -Fast allSat, Looking for solution 1832 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s45) -Fast allSat, Looking for solution 1833 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s43) -Fast allSat, Looking for solution 1834 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s86) -Fast allSat, Looking for solution 1835 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s54) -Fast allSat, Looking for solution 1836 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s55) -Fast allSat, Looking for solution 1837 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s56) -Fast allSat, Looking for solution 1838 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s57) -Fast allSat, Looking for solution 1839 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s58) -[GOOD] (assert s59) -Fast allSat, Looking for solution 1839 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -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 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -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 s63) -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 s64) -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 s65) -Fast allSat, Looking for solution 1844 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -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 s67) -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 s68) -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 s69) -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 s70) -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 s71) -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 s88) -Fast allSat, Looking for solution 1851 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s72) -[GOOD] (assert s73) -Fast allSat, Looking for solution 1851 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1852 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1853 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1854 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1855 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1856 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1857 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1858 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1859 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1860 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 1861 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1862 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1863 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s58) -[GOOD] (assert s74) -Fast allSat, Looking for solution 1863 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1864 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1865 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1866 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1867 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1868 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1869 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1870 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1871 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1872 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 1873 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1874 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1875 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s60) -[GOOD] (assert s75) -Fast allSat, Looking for solution 1875 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 1876 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1877 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1878 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1879 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1880 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1881 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[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 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1883 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1884 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 1885 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1886 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -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 s71) -[GOOD] (assert s89) -Fast allSat, Looking for solution 1887 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1888 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[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 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1890 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1891 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[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 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[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 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[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 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[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 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1896 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1897 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1898 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1899 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s88) -[GOOD] (assert s85) -Fast allSat, Looking for solution 1899 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1900 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1901 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1902 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1903 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[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 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1905 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1906 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1907 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1908 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1909 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1910 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1911 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s71) -[GOOD] (assert s84) -Fast allSat, Looking for solution 1911 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1912 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1913 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1914 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1915 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1916 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1917 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1918 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1919 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1920 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1921 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1922 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 1923 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s71) -[GOOD] (assert s83) -Fast allSat, Looking for solution 1923 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1924 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 1925 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1926 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1927 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1928 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1929 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1930 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1931 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1932 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1933 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1934 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1935 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s71) -[GOOD] (assert s82) -Fast allSat, Looking for solution 1935 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1936 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[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 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 1938 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1939 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[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 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1941 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1942 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1943 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1944 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1945 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1946 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1947 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s71) -[GOOD] (assert s81) -Fast allSat, Looking for solution 1947 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 1948 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1949 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1950 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1951 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1952 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1953 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1954 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1955 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1956 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1957 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1958 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1959 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s71) -[GOOD] (assert s80) -Fast allSat, Looking for solution 1959 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1960 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1961 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[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 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1963 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 1964 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1965 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1966 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1967 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1968 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1969 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1970 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1971 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s71) -[GOOD] (assert s79) -Fast allSat, Looking for solution 1971 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1972 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1973 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1974 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1975 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1976 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 1977 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 1978 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1979 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1980 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1981 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1982 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1983 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s71) -[GOOD] (assert s78) -Fast allSat, Looking for solution 1983 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1984 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1985 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1986 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1987 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 1988 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 1989 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 1990 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 1991 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 1992 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 1993 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 1994 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 1995 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s64) -[GOOD] (assert s98) -[GOOD] (assert s77) -Fast allSat, Looking for solution 1995 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 1996 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 1997 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 1998 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 1999 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2000 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2001 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2002 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 2003 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2004 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2005 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2006 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 5)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2007 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s53) -[GOOD] (define-fun s99 () Bool (= s0 s20)) -[GOOD] (assert s99) -Fast allSat, Looking for solution 2007 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s52) -Fast allSat, Looking for solution 2008 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s51) -Fast allSat, Looking for solution 2009 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s50) -Fast allSat, Looking for solution 2010 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s49) -Fast allSat, Looking for solution 2011 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s48) -Fast allSat, Looking for solution 2012 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s47) -Fast allSat, Looking for solution 2013 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s46) -Fast allSat, Looking for solution 2014 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s45) -Fast allSat, Looking for solution 2015 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s43) -Fast allSat, Looking for solution 2016 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s86) -Fast allSat, Looking for solution 2017 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s55) -Fast allSat, Looking for solution 2018 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s56) -Fast allSat, Looking for solution 2019 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s57) -Fast allSat, Looking for solution 2020 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s58) -[GOOD] (assert s59) -Fast allSat, Looking for solution 2020 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2021 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2022 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2023 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2024 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2025 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2026 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2027 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2028 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2029 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2030 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2031 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 2032 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s72) -[GOOD] (assert s73) -Fast allSat, Looking for solution 2032 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2033 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2034 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2035 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2036 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2037 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2038 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2039 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2040 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2041 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2042 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 2043 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2044 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s58) -[GOOD] (assert s74) -Fast allSat, Looking for solution 2044 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[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 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[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 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[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 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2048 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[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 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[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 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2051 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2052 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2053 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2054 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 2055 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2056 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s71) -[GOOD] (assert s89) -Fast allSat, Looking for solution 2056 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2057 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2058 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2059 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2060 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2061 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2062 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[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 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2064 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2065 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2066 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2067 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2068 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s88) -[GOOD] (assert s85) -Fast allSat, Looking for solution 2068 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2069 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2070 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2071 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2072 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2073 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2074 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2075 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2076 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2077 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2078 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2079 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -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 s71) -[GOOD] (assert s84) -Fast allSat, Looking for solution 2080 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2081 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[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 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2083 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[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 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2085 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[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 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2087 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2088 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 2089 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2090 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2091 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2092 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s71) -[GOOD] (assert s83) -Fast allSat, Looking for solution 2092 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 2093 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[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 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2095 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2096 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2097 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2098 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2099 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[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 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2101 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2102 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2103 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2104 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s71) -[GOOD] (assert s82) -Fast allSat, Looking for solution 2104 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 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 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2106 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2107 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[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 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2109 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2110 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2111 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2112 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2113 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2114 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2115 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2116 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s71) -[GOOD] (assert s81) -Fast allSat, Looking for solution 2116 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2117 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2118 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2119 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 2120 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2121 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2122 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2123 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2124 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2125 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2126 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2127 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -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 s71) -[GOOD] (assert s80) -Fast allSat, Looking for solution 2128 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2129 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2130 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2131 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2132 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 2133 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2134 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2135 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2136 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2137 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2138 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2139 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2140 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s71) -[GOOD] (assert s79) -Fast allSat, Looking for solution 2140 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 2141 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[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 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2143 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2144 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2145 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2146 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2147 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2148 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2149 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2150 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2151 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2152 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s71) -[GOOD] (assert s78) -Fast allSat, Looking for solution 2152 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2153 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2154 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2155 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2156 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2157 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2158 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 2159 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2160 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2161 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2162 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2163 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2164 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s71) -[GOOD] (assert s77) -Fast allSat, Looking for solution 2164 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2165 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2166 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[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 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2168 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2169 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2170 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2171 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 2172 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2173 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2174 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2175 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2176 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s63) -[GOOD] (assert s99) -[GOOD] (assert s76) -Fast allSat, Looking for solution 2176 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2177 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2178 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[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 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2180 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2181 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2182 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2183 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2184 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 2185 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2186 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2187 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 4)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2188 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s54) -[GOOD] (define-fun s100 () Bool (= s0 s18)) -[GOOD] (assert s100) -Fast allSat, Looking for solution 2188 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s53) -Fast allSat, Looking for solution 2189 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s52) -Fast allSat, Looking for solution 2190 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s51) -Fast allSat, Looking for solution 2191 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s50) -Fast allSat, Looking for solution 2192 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s49) -Fast allSat, Looking for solution 2193 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s48) -Fast allSat, Looking for solution 2194 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s47) -Fast allSat, Looking for solution 2195 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s46) -Fast allSat, Looking for solution 2196 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s45) -Fast allSat, Looking for solution 2197 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s43) -Fast allSat, Looking for solution 2198 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s86) -Fast allSat, Looking for solution 2199 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s56) -Fast allSat, Looking for solution 2200 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s57) -Fast allSat, Looking for solution 2201 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s58) -[GOOD] (assert s59) -Fast allSat, Looking for solution 2201 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2202 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2203 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2204 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2205 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2206 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2207 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2208 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2209 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2210 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2211 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2212 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 2213 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s72) -[GOOD] (assert s73) -Fast allSat, Looking for solution 2213 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2214 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2215 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2216 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2217 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2218 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2219 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2220 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2221 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2222 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2223 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2224 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 2225 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s71) -[GOOD] (assert s89) -Fast allSat, Looking for solution 2225 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2226 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2227 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2228 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2229 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2230 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2231 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2232 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2233 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2234 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2235 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2236 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2237 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s88) -[GOOD] (assert s85) -Fast allSat, Looking for solution 2237 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2238 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2239 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2240 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2241 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2242 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2243 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2244 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2245 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2246 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2247 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2248 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2249 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s71) -[GOOD] (assert s84) -Fast allSat, Looking for solution 2249 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2250 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2251 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2252 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2253 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2254 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2255 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2256 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2257 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2258 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 2259 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2260 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2261 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s70) -[GOOD] (assert s83) -Fast allSat, Looking for solution 2261 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2262 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 2263 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2264 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2265 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2266 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2267 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2268 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2269 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2270 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2271 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2272 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2273 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s69) -[GOOD] (assert s82) -Fast allSat, Looking for solution 2273 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2274 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2275 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 2276 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2277 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2278 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2279 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2280 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2281 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2282 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2283 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2284 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2285 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s68) -[GOOD] (assert s81) -Fast allSat, Looking for solution 2285 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2286 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2287 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2288 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 2289 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2290 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2291 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2292 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2293 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2294 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2295 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2296 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2297 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s68) -[GOOD] (assert s80) -Fast allSat, Looking for solution 2297 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2298 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2299 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2300 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 2301 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2302 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2303 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2304 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2305 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2306 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2307 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2308 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -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 s68) -[GOOD] (assert s79) -Fast allSat, Looking for solution 2309 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2310 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2311 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2312 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 2313 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2314 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2315 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2316 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2317 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2318 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2319 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2320 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2321 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s68) -[GOOD] (assert s78) -Fast allSat, Looking for solution 2321 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2322 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2323 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2324 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2325 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2326 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2327 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 2328 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2329 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2330 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2331 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2332 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -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 s68) -[GOOD] (assert s77) -Fast allSat, Looking for solution 2333 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2334 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2335 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2336 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2337 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2338 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2339 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2340 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 2341 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2342 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2343 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2344 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2345 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s68) -[GOOD] (assert s76) -Fast allSat, Looking for solution 2345 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2346 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2347 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2348 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2349 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2350 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2351 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2352 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2353 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 2354 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2355 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2356 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2357 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s62) -[GOOD] (assert s100) -[GOOD] (assert s75) -Fast allSat, Looking for solution 2357 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2358 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2359 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2360 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2361 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2362 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2363 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2364 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2365 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2366 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 2367 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2368 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 3)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2369 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s55) -[GOOD] (define-fun s101 () Bool (= s0 s16)) -[GOOD] (assert s101) -Fast allSat, Looking for solution 2369 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s57) -Fast allSat, Looking for solution 2370 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s54) -Fast allSat, Looking for solution 2371 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s53) -Fast allSat, Looking for solution 2372 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s52) -Fast allSat, Looking for solution 2373 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s51) -Fast allSat, Looking for solution 2374 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s50) -Fast allSat, Looking for solution 2375 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s49) -Fast allSat, Looking for solution 2376 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s48) -Fast allSat, Looking for solution 2377 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s47) -Fast allSat, Looking for solution 2378 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s46) -Fast allSat, Looking for solution 2379 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s45) -Fast allSat, Looking for solution 2380 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s43) -Fast allSat, Looking for solution 2381 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s86) -Fast allSat, Looking for solution 2382 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s71) -[GOOD] (assert s89) -Fast allSat, Looking for solution 2382 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2383 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2384 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2385 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2386 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2387 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2388 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2389 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2390 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2391 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2392 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2393 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 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 s85) -Fast allSat, Looking for solution 2394 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2395 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2396 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2397 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2398 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2399 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2400 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2401 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2402 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2403 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2404 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2405 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 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 s71) -[GOOD] (assert s84) -Fast allSat, Looking for solution 2406 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2407 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2408 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2409 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2410 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2411 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2412 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2413 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2414 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2415 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2416 -[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 2417 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 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 s70) -[GOOD] (assert s83) -Fast allSat, Looking for solution 2418 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2419 -[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 2420 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2421 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2422 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2423 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2424 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2425 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2426 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2427 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2428 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2429 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 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 s69) -[GOOD] (assert s82) -Fast allSat, Looking for solution 2430 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2431 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2432 -[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 2433 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2434 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2435 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2436 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2437 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2438 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2439 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2440 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2441 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 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 s68) -[GOOD] (assert s81) -Fast allSat, Looking for solution 2442 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2443 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2444 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2445 -[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 2446 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2447 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2448 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2449 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2450 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2451 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2452 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2453 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 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 s67) -[GOOD] (assert s80) -Fast allSat, Looking for solution 2454 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2455 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2456 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2457 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2458 -[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 2459 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2460 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2461 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2462 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2463 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2464 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2465 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2466 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s67) -[GOOD] (assert s79) -Fast allSat, Looking for solution 2466 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2467 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2468 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2469 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2470 -[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 2471 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2472 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2473 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2474 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2475 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2476 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2477 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2478 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s67) -[GOOD] (assert s78) -Fast allSat, Looking for solution 2478 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2479 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2480 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2481 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2482 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2483 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2484 -[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 2485 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2486 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2487 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2488 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2489 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2490 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s67) -[GOOD] (assert s77) -Fast allSat, Looking for solution 2490 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2491 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2492 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2493 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2494 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2495 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2496 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2497 -[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 2498 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2499 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2500 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2501 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2502 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s67) -[GOOD] (assert s76) -Fast allSat, Looking for solution 2502 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2503 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2504 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2505 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2506 -[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 2507 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2508 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2509 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2510 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2511 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2512 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2513 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2514 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s67) -[GOOD] (assert s75) -Fast allSat, Looking for solution 2514 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2515 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2516 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2517 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2518 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2519 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2520 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2521 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2522 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2523 -[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 2524 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2525 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2526 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s67) -[GOOD] (assert s59) -Fast allSat, Looking for solution 2526 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2527 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2528 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2529 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2530 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2531 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2532 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2533 -[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 2534 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2535 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2536 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2537 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 1)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2538 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s61) -[GOOD] (assert s101) -[GOOD] (assert s74) -Fast allSat, Looking for solution 2538 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2539 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2540 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2541 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2542 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2543 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2544 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2545 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2546 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2547 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s71) -Fast allSat, Looking for solution 2548 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 2549 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 2)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 1)) -[GOOD] (push 1) -[GOOD] (assert s72) -Fast allSat, Looking for solution 2550 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s56) -[GOOD] (define-fun s102 () Bool (= s0 s3)) -[GOOD] (assert s102) -Fast allSat, Looking for solution 2550 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s55) -Fast allSat, Looking for solution 2551 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s54) -Fast allSat, Looking for solution 2552 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s53) -Fast allSat, Looking for solution 2553 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s52) -Fast allSat, Looking for solution 2554 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s51) -Fast allSat, Looking for solution 2555 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s50) -Fast allSat, Looking for solution 2556 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s49) -Fast allSat, Looking for solution 2557 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s48) -Fast allSat, Looking for solution 2558 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s47) -Fast allSat, Looking for solution 2559 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s46) -Fast allSat, Looking for solution 2560 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s45) -Fast allSat, Looking for solution 2561 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s43) -Fast allSat, Looking for solution 2562 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 14)) -[GOOD] (push 1) -[GOOD] (assert s86) -Fast allSat, Looking for solution 2563 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s71) -[GOOD] (assert s89) -Fast allSat, Looking for solution 2563 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2564 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2565 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2566 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2567 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2568 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2569 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2570 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2571 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2572 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2573 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2574 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 15)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2575 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s88) -[GOOD] (assert s85) -Fast allSat, Looking for solution 2575 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2576 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2577 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2578 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2579 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2580 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2581 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2582 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2583 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2584 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2585 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2586 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 14)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2587 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s71) -[GOOD] (assert s84) -Fast allSat, Looking for solution 2587 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 13)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -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 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -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 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -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 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -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 s66) -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 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -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 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -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 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -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 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -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 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -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 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -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 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -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 s71) -[GOOD] (assert s83) -Fast allSat, Looking for solution 2599 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -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 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 2601 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -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 s67) -Fast allSat, Looking for solution 2603 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert 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 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2605 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2606 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2607 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2608 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2609 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2610 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 12)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -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 s71) -[GOOD] (assert s82) -Fast allSat, Looking for solution 2611 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -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 s70) -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 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -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 s67) -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 s66) -Fast allSat, Looking for solution 2616 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 11)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -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 s64) -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 s63) -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 s62) -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 s61) -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 s60) -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 s58) -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 s71) -[GOOD] (assert s81) -Fast allSat, Looking for solution 2623 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -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 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -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 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -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 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2627 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2628 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -Fast allSat, Looking for solution 2629 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2630 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2631 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2632 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2633 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2634 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 10)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2635 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s71) -[GOOD] (assert s80) -Fast allSat, Looking for solution 2635 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 9)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -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 s70) -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 s69) -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 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 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -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 s65) -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 s64) -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 s63) -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 s62) -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 s61) -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 s60) -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 s58) -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 s71) -[GOOD] (assert s79) -Fast allSat, Looking for solution 2647 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -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 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2649 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2650 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[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 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2652 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2653 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -Fast allSat, Looking for solution 2654 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2655 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -Fast allSat, Looking for solution 2656 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -Fast allSat, Looking for solution 2657 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2658 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 8)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2659 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s71) -[GOOD] (assert s78) -Fast allSat, Looking for solution 2659 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 7)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -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 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -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 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -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 s68) -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 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -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 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -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 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -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 s63) -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 s62) -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 s61) -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 s60) -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 s58) -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 s71) -[GOOD] (assert s77) -Fast allSat, Looking for solution 2671 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 6)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -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 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -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 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -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 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -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 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -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 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -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 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -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 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -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 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -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 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -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 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -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 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -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 s71) -[GOOD] (assert s76) -Fast allSat, Looking for solution 2683 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -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 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 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -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 s68) -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 s67) -Fast allSat, Looking for solution 2688 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2689 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 5)) -[SEND] (get-value (s2)) -[RECV] ((s2 8)) -[GOOD] (push 1) -[GOOD] (assert s65) -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 s64) -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 s63) -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 s61) -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 s60) -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 s58) -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 s71) -[GOOD] (assert s75) -Fast allSat, Looking for solution 2695 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 5)) -[GOOD] (push 1) -[GOOD] (assert s62) -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 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -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 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -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 8)) -[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 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -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 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -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 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -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 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -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 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2704 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -Fast allSat, Looking for solution 2705 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 3)) -[GOOD] (push 1) -[GOOD] (assert s60) -Fast allSat, Looking for solution 2706 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 4)) -[SEND] (get-value (s2)) -[RECV] ((s2 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2707 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s71) -[GOOD] (assert s74) -Fast allSat, Looking for solution 2707 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -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 s62) -Fast allSat, Looking for solution 2709 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 6)) -[GOOD] (push 1) -[GOOD] (assert s63) -Fast allSat, Looking for solution 2710 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 7)) -[GOOD] (push 1) -[GOOD] (assert s64) -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 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 9)) -[GOOD] (push 1) -[GOOD] (assert s66) -Fast allSat, Looking for solution 2713 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 10)) -[GOOD] (push 1) -[GOOD] (assert s67) -Fast allSat, Looking for solution 2714 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 11)) -[GOOD] (push 1) -[GOOD] (assert s68) -Fast allSat, Looking for solution 2715 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2716 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -Fast allSat, Looking for solution 2717 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 3)) -[SEND] (get-value (s2)) -[RECV] ((s2 15)) -[GOOD] (push 1) -[GOOD] (assert s88) -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 2)) -[GOOD] (push 1) -[GOOD] (assert s58) -Fast allSat, Looking for solution 2719 -[SEND] (check-sat) -[RECV] unsat -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (pop 1) -[GOOD] (push 1) -[GOOD] (assert s60) -[GOOD] (assert s102) -[GOOD] (assert s73) -Fast allSat, Looking for solution 2719 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 4)) -[GOOD] (push 1) -[GOOD] (assert s61) -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 s62) -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 s63) -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 s64) -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 s65) -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 s66) -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 s67) -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 s68) -Fast allSat, Looking for solution 2727 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 12)) -[GOOD] (push 1) -[GOOD] (assert s69) -Fast allSat, Looking for solution 2728 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (s0)) -[RECV] ((s0 1)) -[SEND] (get-value (s1)) -[RECV] ((s1 2)) -[SEND] (get-value (s2)) -[RECV] ((s2 13)) -[GOOD] (push 1) -[GOOD] (assert s70) -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 s71) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 42 +[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 s62) +Fast allSat, Looking for solution 43 +[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 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 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 45 +[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 s64) +Fast allSat, Looking for solution 46 +[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 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 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 48 +[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 s67) +Fast allSat, Looking for solution 49 +[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 s68) +Fast allSat, Looking for solution 50 +[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 s69) +Fast allSat, Looking for solution 51 +[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 s70) +Fast allSat, Looking for solution 52 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +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 s58) +[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 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 54 +[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 s66) +Fast allSat, Looking for solution 55 +[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 s65) +Fast allSat, Looking for solution 56 +[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 s64) +Fast allSat, Looking for solution 57 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[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 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 59 +[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 s61) +Fast allSat, Looking for solution 60 +[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 s68) +Fast allSat, Looking for solution 61 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 62 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 63 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 64 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +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 s60) +[GOOD] (define-fun s75 () Bool (= s1 s20)) +[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 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 66 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 67 +[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 s62) +Fast allSat, Looking for solution 68 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 69 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 70 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[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 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 72 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 73 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 74 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 75 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 76 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 77 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s61) +[GOOD] (define-fun s76 () Bool (= s1 s22)) +[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 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 78 +[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 s64) +Fast allSat, Looking for solution 79 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 80 +[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 s66) +Fast allSat, Looking for solution 81 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 82 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 83 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 84 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 85 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 86 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 87 +[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 s58) +Fast allSat, Looking for solution 88 +[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 s72) +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 s62) +[GOOD] (define-fun s77 () Bool (= s1 s24)) +[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 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 90 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 91 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 92 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 93 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 94 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 95 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 96 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 97 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 98 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 99 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 100 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 101 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s63) +[GOOD] (define-fun s78 () Bool (= s1 s26)) +[GOOD] (assert s78) +Fast allSat, Looking for solution 101 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 102 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 103 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 104 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 105 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 106 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 107 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 108 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 109 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 110 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 111 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 112 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 113 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s64) +[GOOD] (define-fun s79 () Bool (= s1 s28)) +[GOOD] (assert s79) +Fast allSat, Looking for solution 113 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 114 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 115 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 116 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 117 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 118 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 119 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 120 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 121 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 122 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 123 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 124 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 125 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s65) +[GOOD] (define-fun s80 () Bool (= s1 s30)) +[GOOD] (assert s80) +Fast allSat, Looking for solution 125 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 126 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 127 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 128 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 129 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 130 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 131 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 132 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 133 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 134 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 135 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 136 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 137 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s66) +[GOOD] (define-fun s81 () Bool (= s1 s32)) +[GOOD] (assert s81) +Fast allSat, Looking for solution 137 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 138 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 139 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 140 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 141 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 142 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 143 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 144 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 145 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 146 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 147 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 148 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 149 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s67) +[GOOD] (define-fun s82 () Bool (= s1 s34)) +[GOOD] (assert s82) +Fast allSat, Looking for solution 149 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 150 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 151 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 152 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 153 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 154 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 155 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 156 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 157 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 158 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 159 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 160 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 161 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s68) +[GOOD] (define-fun s83 () Bool (= s1 s36)) +[GOOD] (assert s83) +Fast allSat, Looking for solution 161 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 162 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 163 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 164 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 165 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 166 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 167 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 168 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 169 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 170 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 171 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 172 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 173 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s69) +[GOOD] (define-fun s84 () Bool (= s1 s38)) +[GOOD] (assert s84) +Fast allSat, Looking for solution 173 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 174 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 175 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 176 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 177 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 178 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 179 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 180 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 181 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 182 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 183 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 184 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 185 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s70) +[GOOD] (assert s44) +[GOOD] (define-fun s85 () Bool (= s1 s40)) +[GOOD] (assert s85) +Fast allSat, Looking for solution 185 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 186 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 187 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 188 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 189 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 190 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 191 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 192 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 193 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 194 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 195 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 196 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 15)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 197 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (define-fun s86 () Bool (distinct s1 s5)) +[GOOD] (assert s86) +[GOOD] (define-fun s87 () Bool (= s0 s40)) +[GOOD] (assert s87) +Fast allSat, Looking for solution 197 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s45) +Fast allSat, Looking for solution 198 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s46) +Fast allSat, Looking for solution 199 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s47) +Fast allSat, Looking for solution 200 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s48) +Fast allSat, Looking for solution 201 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s49) +Fast allSat, Looking for solution 202 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s50) +Fast allSat, Looking for solution 203 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s51) +Fast allSat, Looking for solution 204 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s52) +Fast allSat, Looking for solution 205 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s53) +Fast allSat, Looking for solution 206 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s54) +Fast allSat, Looking for solution 207 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s55) +Fast allSat, Looking for solution 208 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s56) +Fast allSat, Looking for solution 209 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s57) +Fast allSat, Looking for solution 210 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s58) +[GOOD] (assert s59) +Fast allSat, Looking for solution 210 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[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 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[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 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[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 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[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 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[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 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 216 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[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 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[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 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[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 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[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 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[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 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 s72) +[GOOD] (assert s73) +Fast allSat, Looking for solution 222 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 223 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 224 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 225 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 226 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 227 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 228 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[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 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 230 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 231 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 232 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 233 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 234 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s58) +[GOOD] (assert s74) +Fast allSat, Looking for solution 234 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 235 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 236 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 237 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 238 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 239 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 240 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 241 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 242 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 243 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 244 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 245 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 s60) +[GOOD] (assert s75) +Fast allSat, Looking for solution 246 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[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 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 248 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 249 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 250 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 251 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 252 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 253 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 254 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 255 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 256 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 257 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 258 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s61) +[GOOD] (assert s76) +Fast allSat, Looking for solution 258 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 259 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 260 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 261 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 262 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 263 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 264 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 265 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 266 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 267 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 268 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 269 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 s62) +[GOOD] (assert s77) +Fast allSat, Looking for solution 270 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[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 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 272 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 273 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 274 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 275 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 276 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 277 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 278 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 279 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 280 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 281 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 282 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s63) +[GOOD] (assert s78) +Fast allSat, Looking for solution 282 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 283 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 284 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 285 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 286 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 287 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 288 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 289 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 290 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 291 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 292 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 293 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 294 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s64) +[GOOD] (assert s79) +Fast allSat, Looking for solution 294 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[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 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 296 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 297 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 298 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 299 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 300 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 301 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 302 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 303 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 304 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 305 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 306 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert 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 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 307 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 308 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 309 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 310 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 311 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 312 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 313 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 314 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 315 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 316 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 317 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 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 s66) +[GOOD] (assert s81) +Fast allSat, Looking for solution 318 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[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 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 320 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 321 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 322 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 323 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 324 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 325 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 326 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 327 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 328 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 329 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 330 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s67) +[GOOD] (assert s82) +Fast allSat, Looking for solution 330 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 331 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 332 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 333 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 334 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 335 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 336 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 337 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 338 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 339 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 340 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 341 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 342 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s68) +[GOOD] (assert s83) +Fast allSat, Looking for solution 342 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 343 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 344 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 345 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 346 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 347 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 348 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 349 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 350 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 351 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 352 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 353 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 354 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s69) +[GOOD] (assert s84) +Fast allSat, Looking for solution 354 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 355 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 356 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 357 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 358 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 359 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 360 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 361 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 362 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 363 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 364 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[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 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 366 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s70) +[GOOD] (assert s87) +[GOOD] (define-fun s89 () Bool (= s1 s5)) +[GOOD] (assert s89) +Fast allSat, Looking for solution 366 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 367 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 368 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 369 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 370 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 371 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 372 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 373 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 374 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 375 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 376 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 377 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 14)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 378 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s43) +[GOOD] (define-fun s90 () Bool (= s0 s38)) +[GOOD] (assert s90) +Fast allSat, Looking for solution 378 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s86) +Fast allSat, Looking for solution 379 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s46) +Fast allSat, Looking for solution 380 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s47) +Fast allSat, Looking for solution 381 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s48) +Fast allSat, Looking for solution 382 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s49) +Fast allSat, Looking for solution 383 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s50) +Fast allSat, Looking for solution 384 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s51) +Fast allSat, Looking for solution 385 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s52) +Fast allSat, Looking for solution 386 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s53) +Fast allSat, Looking for solution 387 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s54) +Fast allSat, Looking for solution 388 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s55) +Fast allSat, Looking for solution 389 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s56) +Fast allSat, Looking for solution 390 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s57) +Fast allSat, Looking for solution 391 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s58) +[GOOD] (assert s59) +Fast allSat, Looking for solution 391 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 392 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 393 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 394 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 395 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 396 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 397 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 398 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 399 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 400 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 401 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 402 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 403 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s72) +[GOOD] (assert s73) +Fast allSat, Looking for solution 403 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 404 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 405 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 406 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 407 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 408 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 409 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 410 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 411 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 412 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 413 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 414 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 415 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s58) +[GOOD] (assert s74) +Fast allSat, Looking for solution 415 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 416 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 417 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 418 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 419 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 420 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 421 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 422 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 423 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 424 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 425 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 426 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 427 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s60) +[GOOD] (assert s75) +Fast allSat, Looking for solution 427 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 428 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 429 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 430 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 431 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 432 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 433 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 434 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 435 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 436 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 437 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 438 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +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 s61) +[GOOD] (assert s76) +Fast allSat, Looking for solution 439 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 440 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 441 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 442 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 443 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 444 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 445 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 446 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 447 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 448 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 449 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 450 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +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 s62) +[GOOD] (assert s77) +Fast allSat, Looking for solution 451 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 452 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 453 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 454 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 455 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 456 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 457 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 458 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 459 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 460 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 461 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 462 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +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 s63) +[GOOD] (assert s78) +Fast allSat, Looking for solution 463 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 464 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 465 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 466 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 467 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 468 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 469 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 470 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[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 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[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 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[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 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 474 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +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 s64) +[GOOD] (assert s79) +Fast allSat, Looking for solution 475 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 476 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 477 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 478 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 479 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 480 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 481 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 482 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 483 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 484 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 485 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 486 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +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 s65) +[GOOD] (assert s80) +Fast allSat, Looking for solution 487 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 488 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 489 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 490 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 491 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 492 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[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 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[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 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[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 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[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 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[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 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 498 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +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 s66) +[GOOD] (assert s81) +Fast allSat, Looking for solution 499 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 500 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 501 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 502 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 503 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 504 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 505 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[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 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[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 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[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 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[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 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 510 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +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 s67) +[GOOD] (assert s82) +Fast allSat, Looking for solution 511 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 512 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 513 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 514 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 515 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 516 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 517 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 518 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[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 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[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 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[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 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 522 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +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 s68) +[GOOD] (assert s83) +Fast allSat, Looking for solution 523 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 524 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 525 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 526 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 527 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 528 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 529 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 530 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 531 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[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 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[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 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 534 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +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 s71) +[GOOD] (assert s89) +Fast allSat, Looking for solution 535 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 536 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 537 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 538 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 539 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 540 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 541 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 542 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 543 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 544 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[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 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 546 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 547 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s88) +[GOOD] (assert s90) +[GOOD] (assert s85) +Fast allSat, Looking for solution 547 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 548 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 549 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 550 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 551 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 552 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 553 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 554 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 555 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 556 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 557 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 558 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 13)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 559 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s45) +[GOOD] (define-fun s91 () Bool (= s0 s36)) +[GOOD] (assert s91) +Fast allSat, Looking for solution 559 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s43) +Fast allSat, Looking for solution 560 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s86) +Fast allSat, Looking for solution 561 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s47) +Fast allSat, Looking for solution 562 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s48) +Fast allSat, Looking for solution 563 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s49) +Fast allSat, Looking for solution 564 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s50) +Fast allSat, Looking for solution 565 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s51) +Fast allSat, Looking for solution 566 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s52) +Fast allSat, Looking for solution 567 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s53) +Fast allSat, Looking for solution 568 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s54) +Fast allSat, Looking for solution 569 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s55) +Fast allSat, Looking for solution 570 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s56) +Fast allSat, Looking for solution 571 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s57) +Fast allSat, Looking for solution 572 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s58) +[GOOD] (assert s59) +Fast allSat, Looking for solution 572 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 573 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 574 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 575 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 576 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 577 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 578 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 579 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 580 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 581 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 582 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 583 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 584 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s72) +[GOOD] (assert s73) +Fast allSat, Looking for solution 584 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 585 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 586 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 587 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 588 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 589 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 590 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 591 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 592 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 593 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 594 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 595 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 596 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s58) +[GOOD] (assert s74) +Fast allSat, Looking for solution 596 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[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 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[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 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 599 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 600 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 601 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 602 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 603 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 604 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 605 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 606 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 607 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 608 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s60) +[GOOD] (assert s75) +Fast allSat, Looking for solution 608 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 609 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 610 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 611 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[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 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[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 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[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 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 615 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[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 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[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 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[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 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 619 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 620 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s61) +[GOOD] (assert s76) +Fast allSat, Looking for solution 620 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 621 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 622 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 623 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 624 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 625 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 626 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 627 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 628 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 629 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 630 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 631 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 632 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s62) +[GOOD] (assert s77) +Fast allSat, Looking for solution 632 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 633 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 634 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 635 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[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 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[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 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 638 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[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 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[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 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 641 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 642 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 643 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 644 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s63) +[GOOD] (assert s78) +Fast allSat, Looking for solution 644 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 645 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 646 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 647 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 648 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 649 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 650 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 651 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 652 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 653 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 654 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 655 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 656 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s64) +[GOOD] (assert s79) +Fast allSat, Looking for solution 656 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 657 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 658 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 659 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 660 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 661 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 662 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 663 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 664 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 665 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 666 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 667 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 668 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s65) +[GOOD] (assert s80) +Fast allSat, Looking for solution 668 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 669 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 670 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 671 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 672 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 673 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 674 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 675 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 676 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 677 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 678 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 679 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 680 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s66) +[GOOD] (assert s81) +Fast allSat, Looking for solution 680 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 681 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 682 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 683 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 684 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 685 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 686 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 687 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 688 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 689 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 690 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 691 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 692 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s67) +[GOOD] (assert s82) +Fast allSat, Looking for solution 692 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 693 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 694 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 695 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 696 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 697 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 698 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 699 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 700 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 701 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 702 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 703 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 704 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s68) +[GOOD] (assert s89) +Fast allSat, Looking for solution 704 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 705 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 706 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 707 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 708 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 709 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 710 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 711 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 712 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 713 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 714 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 715 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 716 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s68) +[GOOD] (assert s85) +Fast allSat, Looking for solution 716 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 717 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 718 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 719 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[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 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 721 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 722 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 723 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 724 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[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 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 726 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[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 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[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 s71) +[GOOD] (assert s91) +[GOOD] (assert s84) +Fast allSat, Looking for solution 728 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 729 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 730 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 731 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 732 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 733 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 734 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 735 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 736 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 737 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 738 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 739 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 12)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 740 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s46) +[GOOD] (define-fun s92 () Bool (= s0 s34)) +[GOOD] (assert s92) +Fast allSat, Looking for solution 740 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s45) +Fast allSat, Looking for solution 741 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s43) +Fast allSat, Looking for solution 742 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s48) +Fast allSat, Looking for solution 743 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s49) +Fast allSat, Looking for solution 744 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s50) +Fast allSat, Looking for solution 745 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s51) +Fast allSat, Looking for solution 746 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s52) +Fast allSat, Looking for solution 747 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s53) +Fast allSat, Looking for solution 748 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s54) +Fast allSat, Looking for solution 749 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s55) +Fast allSat, Looking for solution 750 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s56) +Fast allSat, Looking for solution 751 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s57) +Fast allSat, Looking for solution 752 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s86) +Fast allSat, Looking for solution 753 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s71) +[GOOD] (assert s89) +Fast allSat, Looking for solution 753 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 754 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 755 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 756 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 757 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 758 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 759 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 760 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 761 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 762 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 763 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 764 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 765 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s69) +[GOOD] (assert s59) +Fast allSat, Looking for solution 765 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 766 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 767 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 768 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 769 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 770 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 771 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 772 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 773 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 774 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 775 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 776 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 777 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s69) +[GOOD] (assert s73) +Fast allSat, Looking for solution 777 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 778 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 779 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 780 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 781 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 782 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 783 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 784 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 785 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 786 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 787 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 788 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 789 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s69) +[GOOD] (assert s74) +Fast allSat, Looking for solution 789 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 790 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 791 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 792 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 793 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 794 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 795 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 796 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 797 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 798 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 799 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 800 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 801 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s69) +[GOOD] (assert s75) +Fast allSat, Looking for solution 801 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 802 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 803 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 804 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 805 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 806 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 807 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 808 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 809 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 810 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 811 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 812 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 813 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s69) +[GOOD] (assert s76) +Fast allSat, Looking for solution 813 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 814 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 815 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 816 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 817 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 818 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 819 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 820 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 821 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 822 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 823 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 824 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 825 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s69) +[GOOD] (assert s77) +Fast allSat, Looking for solution 825 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 826 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 827 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 828 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 829 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 830 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 831 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 832 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 833 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 834 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 835 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 836 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 837 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s69) +[GOOD] (assert s78) +Fast allSat, Looking for solution 837 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 838 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 839 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 840 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 841 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 842 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 843 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 844 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 845 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 846 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 847 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 848 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 849 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s69) +[GOOD] (assert s79) +Fast allSat, Looking for solution 849 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 850 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 851 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 852 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 853 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 854 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 855 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 856 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 857 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 858 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 859 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 860 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 861 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s69) +[GOOD] (assert s80) +Fast allSat, Looking for solution 861 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[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 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[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 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 864 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 865 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 866 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 867 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 868 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 869 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 870 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 871 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 872 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 873 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s69) +[GOOD] (assert s81) +Fast allSat, Looking for solution 873 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 874 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 875 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 876 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 877 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 878 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 879 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 880 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 881 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 882 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 883 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 884 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 885 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s88) +[GOOD] (assert s85) +Fast allSat, Looking for solution 885 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 886 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 887 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 888 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 889 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 890 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 891 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 892 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 893 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 894 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 895 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 896 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 897 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s71) +[GOOD] (assert s84) +Fast allSat, Looking for solution 897 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 898 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 899 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[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 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 901 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 902 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 903 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 904 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 905 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 906 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 907 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 908 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 909 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s70) +[GOOD] (assert s92) +[GOOD] (assert s83) +Fast allSat, Looking for solution 909 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 910 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 911 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 912 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 913 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 914 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 915 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 916 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 917 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 918 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 919 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 920 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 11)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 921 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s47) +[GOOD] (define-fun s93 () Bool (= s0 s32)) +[GOOD] (assert s93) +Fast allSat, Looking for solution 921 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s46) +Fast allSat, Looking for solution 922 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s45) +Fast allSat, Looking for solution 923 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s43) +Fast allSat, Looking for solution 924 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s86) +Fast allSat, Looking for solution 925 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s49) +Fast allSat, Looking for solution 926 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s50) +Fast allSat, Looking for solution 927 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s51) +Fast allSat, Looking for solution 928 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s52) +Fast allSat, Looking for solution 929 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s53) +Fast allSat, Looking for solution 930 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s54) +Fast allSat, Looking for solution 931 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s55) +Fast allSat, Looking for solution 932 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s56) +Fast allSat, Looking for solution 933 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s57) +Fast allSat, Looking for solution 934 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s68) +[GOOD] (assert s59) +Fast allSat, Looking for solution 934 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 935 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 936 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 937 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +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 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 939 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 940 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +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 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +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 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +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 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +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 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +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 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 946 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s72) +[GOOD] (assert s73) +Fast allSat, Looking for solution 946 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 947 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 948 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 949 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 950 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 951 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 952 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 953 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 954 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 955 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 956 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 957 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +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 s58) +[GOOD] (assert s74) +Fast allSat, Looking for solution 958 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 959 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 960 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 961 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 962 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 963 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 964 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 965 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 966 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 967 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 968 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 969 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 970 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s60) +[GOOD] (assert s75) +Fast allSat, Looking for solution 970 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[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 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[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 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 973 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 974 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 975 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 976 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 977 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 978 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 979 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 980 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 981 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 982 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s61) +[GOOD] (assert s76) +Fast allSat, Looking for solution 982 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 983 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 984 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 985 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 986 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 987 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[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 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[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 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[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 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 991 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 992 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 993 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 994 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s62) +[GOOD] (assert s77) +Fast allSat, Looking for solution 994 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 995 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 996 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 997 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 998 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 999 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1000 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 1001 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1002 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1003 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1004 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1005 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1006 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s63) +[GOOD] (assert s78) +Fast allSat, Looking for solution 1006 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1007 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1008 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1009 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1010 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1011 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 1012 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1013 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1014 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1015 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1016 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1017 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1018 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s64) +[GOOD] (assert s79) +Fast allSat, Looking for solution 1018 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 1019 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1020 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1021 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[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 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1023 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1024 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 1025 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1026 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1027 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1028 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1029 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1030 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s65) +[GOOD] (assert s80) +Fast allSat, Looking for solution 1030 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1031 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1032 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1033 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1034 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1035 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 1036 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 1037 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1038 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1039 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1040 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1041 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1042 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s71) +[GOOD] (assert s89) +Fast allSat, Looking for solution 1042 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1043 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1044 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1045 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 1046 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1047 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 1048 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 1049 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1050 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1051 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1052 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1053 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1054 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s70) +[GOOD] (assert s85) +Fast allSat, Looking for solution 1054 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1055 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1056 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 1057 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1058 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 1059 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 1060 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1061 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[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 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[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 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[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 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[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 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1066 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s69) +[GOOD] (assert s84) +Fast allSat, Looking for solution 1066 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1067 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1068 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1069 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 1070 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1071 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[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 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 1073 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1074 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1075 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1076 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1077 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +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 s68) +[GOOD] (assert s83) +Fast allSat, Looking for solution 1078 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 1079 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1080 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 1081 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 1082 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1083 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1084 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1085 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1086 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1087 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1088 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1089 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1090 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s69) +[GOOD] (assert s93) +[GOOD] (assert s82) +Fast allSat, Looking for solution 1090 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1091 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1092 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1093 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 1094 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1095 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 1096 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 1097 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1098 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1099 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1100 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1101 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 10)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1102 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s48) +[GOOD] (define-fun s94 () Bool (= s0 s30)) +[GOOD] (assert s94) +Fast allSat, Looking for solution 1102 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s47) +Fast allSat, Looking for solution 1103 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s46) +Fast allSat, Looking for solution 1104 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s45) +Fast allSat, Looking for solution 1105 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s43) +Fast allSat, Looking for solution 1106 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s86) +Fast allSat, Looking for solution 1107 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s50) +Fast allSat, Looking for solution 1108 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s51) +Fast allSat, Looking for solution 1109 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s52) +Fast allSat, Looking for solution 1110 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s53) +Fast allSat, Looking for solution 1111 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s54) +Fast allSat, Looking for solution 1112 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s55) +Fast allSat, Looking for solution 1113 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s56) +Fast allSat, Looking for solution 1114 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s57) +Fast allSat, Looking for solution 1115 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s58) +[GOOD] (assert s59) +Fast allSat, Looking for solution 1115 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1116 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1117 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1118 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 1119 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 1120 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1121 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1122 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1123 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1124 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1125 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1126 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1127 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s72) +[GOOD] (assert s73) +Fast allSat, Looking for solution 1127 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1128 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1129 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1130 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1131 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1132 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1133 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1134 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 1135 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 1136 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1137 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1138 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1139 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s58) +[GOOD] (assert s74) +Fast allSat, Looking for solution 1139 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1140 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[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 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1142 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[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 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[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 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1145 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1146 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[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 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 1148 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 1149 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1150 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1151 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s60) +[GOOD] (assert s75) +Fast allSat, Looking for solution 1151 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1152 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1153 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1154 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1155 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1156 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1157 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1158 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 1159 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 1160 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1161 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1162 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1163 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s61) +[GOOD] (assert s76) +Fast allSat, Looking for solution 1163 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1164 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1165 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[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 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1167 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1168 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1169 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[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 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 1171 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 1172 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1173 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1174 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1175 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s62) +[GOOD] (assert s77) +Fast allSat, Looking for solution 1175 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1176 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1177 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[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 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1179 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1180 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1181 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 1182 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1183 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1184 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1185 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1186 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1187 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s63) +[GOOD] (assert s78) +Fast allSat, Looking for solution 1187 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1188 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1189 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1190 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1191 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1192 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1193 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1194 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1195 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1196 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1197 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1198 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1199 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s64) +[GOOD] (assert s79) +Fast allSat, Looking for solution 1199 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1200 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1201 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1202 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1203 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1204 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1205 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 1206 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1207 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1208 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1209 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1210 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +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 s71) +[GOOD] (assert s89) +Fast allSat, Looking for solution 1211 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1212 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1213 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1214 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[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 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1216 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 1217 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 1218 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1219 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1220 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1221 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1222 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +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 s70) +[GOOD] (assert s85) +Fast allSat, Looking for solution 1223 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1224 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1225 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1226 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1227 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1228 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 1229 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 1230 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1231 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1232 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1233 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1234 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1235 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s69) +[GOOD] (assert s84) +Fast allSat, Looking for solution 1235 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1236 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 1237 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 1238 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1239 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1240 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1241 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1242 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1243 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1244 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1245 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1246 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1247 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s68) +[GOOD] (assert s83) +Fast allSat, Looking for solution 1247 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1248 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1249 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1250 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1251 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1252 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 1253 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 1254 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1255 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1256 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1257 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1258 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1259 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s67) +[GOOD] (assert s82) +Fast allSat, Looking for solution 1259 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1260 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1261 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1262 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1263 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1264 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 1265 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 1266 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1267 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1268 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1269 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1270 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1271 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s68) +[GOOD] (assert s94) +[GOOD] (assert s81) +Fast allSat, Looking for solution 1271 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1272 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[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 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1274 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1275 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1276 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 1277 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 1278 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1279 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1280 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1281 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1282 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 9)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1283 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s49) +[GOOD] (define-fun s95 () Bool (= s0 s28)) +[GOOD] (assert s95) +Fast allSat, Looking for solution 1283 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[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 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[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 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[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 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[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 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[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 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[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 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[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 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s48) +Fast allSat, Looking for solution 1291 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s47) +Fast allSat, Looking for solution 1292 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s46) +Fast allSat, Looking for solution 1293 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s45) +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 s43) +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 s86) +Fast allSat, Looking for solution 1296 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s71) +[GOOD] (assert s89) +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 s70) +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 s69) +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 s68) +Fast allSat, Looking for solution 1299 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +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 s66) +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 s64) +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 s63) +Fast allSat, Looking for solution 1303 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1304 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1305 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1306 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1307 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1308 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s88) +[GOOD] (assert s85) +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 s64) +Fast allSat, Looking for solution 1309 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 1310 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1311 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1312 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1313 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +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 s72) +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 s66) +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 s67) +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 s68) +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 s69) +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 s70) +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 s84) +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 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +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 s68) +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 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +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 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +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 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +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 5)) +[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 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +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 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +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 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +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 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +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 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1331 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1332 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s70) +[GOOD] (assert s83) +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 14)) +[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 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +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 s68) +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 s67) +Fast allSat, Looking for solution 1336 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +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 s64) +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 s63) +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 s62) +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 s61) +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 s60) +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 s58) +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 s72) +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 s69) +[GOOD] (assert s82) +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 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1345 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +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 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +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 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +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 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +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 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +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 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 1351 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1352 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +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 3)) +[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 2)) +[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 1)) +[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 s68) +[GOOD] (assert s81) +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 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +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 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 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +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 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +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 s66) +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 s64) +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 s63) +Fast allSat, Looking for solution 1363 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1364 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1365 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1366 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1367 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1368 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s66) +[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 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1369 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1370 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1371 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1372 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1373 +[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 1374 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 1375 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 1376 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1377 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1378 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1379 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1380 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s66) +[GOOD] (assert 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 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1381 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1382 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1383 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1384 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1385 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1386 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 1387 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 1388 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1389 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1390 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1391 +[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 s72) +Fast allSat, Looking for solution 1392 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s66) +[GOOD] (assert 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 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1393 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1394 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1395 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1396 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1397 +[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 1398 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 1399 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 1400 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1401 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1402 +[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 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 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[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 s66) +[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 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1405 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1406 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1407 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1408 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1409 +[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 1410 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 1411 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 1412 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1413 +[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 s60) +Fast allSat, Looking for solution 1414 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1415 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1416 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s66) +[GOOD] (assert 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 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1417 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1418 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1419 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1420 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1421 +[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 1422 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 1423 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 1424 +[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 s61) +Fast allSat, Looking for solution 1425 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1426 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1427 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1428 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s66) +[GOOD] (assert 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 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1429 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1430 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1431 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1432 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1433 +[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 1434 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 1435 +[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 s62) +Fast allSat, Looking for solution 1436 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1437 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1438 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1439 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1440 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s66) +[GOOD] (assert 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 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1441 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1442 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1443 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1444 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1445 +[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 1446 +[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 s63) +Fast allSat, Looking for solution 1447 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1448 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1449 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1450 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1451 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1452 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s67) +[GOOD] (assert s95) +[GOOD] (assert s80) +Fast allSat, Looking for solution 1452 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1453 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1454 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1455 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1456 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1457 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 1458 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 1459 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1460 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1461 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1462 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1463 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 8)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1464 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s50) +[GOOD] (define-fun s96 () Bool (= s0 s26)) +[GOOD] (assert s96) +Fast allSat, Looking for solution 1464 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s49) +Fast allSat, Looking for solution 1465 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s48) +Fast allSat, Looking for solution 1466 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s47) +Fast allSat, Looking for solution 1467 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s46) +Fast allSat, Looking for solution 1468 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s45) +Fast allSat, Looking for solution 1469 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s43) +Fast allSat, Looking for solution 1470 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s86) +Fast allSat, Looking for solution 1471 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s52) +Fast allSat, Looking for solution 1472 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s53) +Fast allSat, Looking for solution 1473 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s54) +Fast allSat, Looking for solution 1474 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s55) +Fast allSat, Looking for solution 1475 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s56) +Fast allSat, Looking for solution 1476 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s57) +Fast allSat, Looking for solution 1477 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s65) +[GOOD] (assert s59) +Fast allSat, Looking for solution 1477 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +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 s67) +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 s68) +Fast allSat, Looking for solution 1480 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +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 s70) +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 s71) +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 s63) +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 s62) +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 s61) +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 s60) +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 s58) +Fast allSat, Looking for solution 1489 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s65) +[GOOD] (assert s73) +Fast allSat, Looking for solution 1489 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 1490 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1491 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1492 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1493 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 1494 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1495 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1496 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1497 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1498 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1499 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1500 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1501 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s65) +[GOOD] (assert s74) +Fast allSat, Looking for solution 1501 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1502 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1503 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1504 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1505 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1506 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1507 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 1508 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 1509 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1510 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1511 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1512 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1513 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s65) +[GOOD] (assert s75) +Fast allSat, Looking for solution 1513 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 1514 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1515 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1516 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1517 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 1518 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1519 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1520 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1521 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1522 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1523 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1524 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1525 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s65) +[GOOD] (assert s76) +Fast allSat, Looking for solution 1525 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1526 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1527 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1528 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1529 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1530 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1531 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 1532 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 1533 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1534 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1535 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1536 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1537 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s65) +[GOOD] (assert s77) +Fast allSat, Looking for solution 1537 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 1538 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1539 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1540 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1541 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1542 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1543 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1544 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1545 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1546 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1547 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1548 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +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 s71) +[GOOD] (assert s89) +Fast allSat, Looking for solution 1549 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1550 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1551 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1552 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1553 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[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 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1555 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 1556 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1557 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1558 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1559 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1560 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1561 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s88) +[GOOD] (assert s85) +Fast allSat, Looking for solution 1561 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[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 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1563 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1564 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1565 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 1566 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1567 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 1568 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1569 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1570 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1571 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1572 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1573 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s71) +[GOOD] (assert s84) +Fast allSat, Looking for solution 1573 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1574 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 1575 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1576 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1577 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1578 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 1579 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1580 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1581 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1582 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1583 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1584 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1585 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s70) +[GOOD] (assert s83) +Fast allSat, Looking for solution 1585 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1586 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1587 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1588 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1589 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 1590 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1591 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[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 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1593 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1594 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1595 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1596 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1597 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s69) +[GOOD] (assert s82) +Fast allSat, Looking for solution 1597 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +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 s71) +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 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +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 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +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 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +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 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +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 s63) +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 s62) +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 s61) +Fast allSat, Looking for solution 1606 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1607 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1608 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1609 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s68) +[GOOD] (assert s81) +Fast allSat, Looking for solution 1609 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +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 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +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 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1612 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert 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 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +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 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +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 6)) +[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 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +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 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +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 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1619 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1620 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1621 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s67) +[GOOD] (assert s80) +Fast allSat, Looking for solution 1621 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +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 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +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 s70) +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 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +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 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +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 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +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 s63) +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 s62) +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 s61) +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 s60) +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 s58) +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 s72) +Fast allSat, Looking for solution 1633 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s66) +[GOOD] (assert s96) +[GOOD] (assert s79) +Fast allSat, Looking for solution 1633 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1634 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1635 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1636 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1637 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1638 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1639 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 1640 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1641 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1642 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1643 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1644 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 7)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1645 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s51) +[GOOD] (define-fun s97 () Bool (= s0 s24)) +[GOOD] (assert s97) +Fast allSat, Looking for solution 1645 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s50) +Fast allSat, Looking for solution 1646 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s49) +Fast allSat, Looking for solution 1647 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s48) +Fast allSat, Looking for solution 1648 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s47) +Fast allSat, Looking for solution 1649 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s46) +Fast allSat, Looking for solution 1650 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s45) +Fast allSat, Looking for solution 1651 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s43) +Fast allSat, Looking for solution 1652 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s53) +Fast allSat, Looking for solution 1653 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s54) +Fast allSat, Looking for solution 1654 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s55) +Fast allSat, Looking for solution 1655 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s56) +Fast allSat, Looking for solution 1656 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[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 s86) +Fast allSat, Looking for solution 1658 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s71) +[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 s70) +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 s69) +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 s68) +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 s67) +Fast allSat, Looking for solution 1662 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +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 s65) +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 s64) +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 s62) +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 s61) +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 s60) +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 s58) +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 s72) +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 s64) +[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 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1671 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1672 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1673 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1674 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1675 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1676 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 1677 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1678 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1679 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1680 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1681 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 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 s64) +[GOOD] (assert s73) +Fast allSat, Looking for solution 1682 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1683 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 1684 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1685 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1686 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1687 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1688 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1689 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1690 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1691 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1692 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1693 +[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 s72) +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 s64) +[GOOD] (assert s74) +Fast allSat, Looking for solution 1694 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1695 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 1696 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1697 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1698 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1699 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1700 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1701 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1702 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1703 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1704 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1705 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 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 s64) +[GOOD] (assert s75) +Fast allSat, Looking for solution 1706 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1707 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1708 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1709 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1710 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1711 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 1712 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1713 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1714 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1715 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1716 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1717 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 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 s64) +[GOOD] (assert s76) +Fast allSat, Looking for solution 1718 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1719 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 1720 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1721 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1722 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1723 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1724 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1725 +[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 1726 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1727 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1728 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1729 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 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 s85) +Fast allSat, Looking for solution 1730 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1731 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1732 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1733 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1734 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 1735 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1736 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[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 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1738 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1739 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1740 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1741 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1742 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s71) +[GOOD] (assert s84) +Fast allSat, Looking for solution 1742 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 1743 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1744 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 1745 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1746 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1747 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1748 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1749 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[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 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[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 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[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 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[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 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[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 s70) +[GOOD] (assert s83) +Fast allSat, Looking for solution 1754 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1755 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1756 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1757 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1758 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 1759 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1760 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 1761 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1762 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1763 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1764 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1765 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1766 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s69) +[GOOD] (assert s82) +Fast allSat, Looking for solution 1766 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1767 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1768 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1769 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1770 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 1771 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1772 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 1773 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[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 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[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 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[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 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[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 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[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 s68) +[GOOD] (assert s81) +Fast allSat, Looking for solution 1778 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1779 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1780 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1781 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1782 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 1783 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1784 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 1785 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1786 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1787 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1788 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1789 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1790 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s67) +[GOOD] (assert s80) +Fast allSat, Looking for solution 1790 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1791 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1792 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1793 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1794 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1795 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1796 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 1797 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert 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 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[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 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[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 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[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 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[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 s66) +[GOOD] (assert s79) +Fast allSat, Looking for solution 1802 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1803 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1804 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1805 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1806 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1807 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1808 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[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 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1810 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1811 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1812 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1813 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1814 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s65) +[GOOD] (assert s97) +[GOOD] (assert s78) +Fast allSat, Looking for solution 1814 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1815 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1816 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[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 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1818 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1819 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1820 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 1821 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 1822 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1823 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1824 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1825 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 6)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1826 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s52) +[GOOD] (define-fun s98 () Bool (= s0 s22)) +[GOOD] (assert s98) +Fast allSat, Looking for solution 1826 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s51) +Fast allSat, Looking for solution 1827 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s50) +Fast allSat, Looking for solution 1828 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s49) +Fast allSat, Looking for solution 1829 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s48) +Fast allSat, Looking for solution 1830 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s47) +Fast allSat, Looking for solution 1831 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s46) +Fast allSat, Looking for solution 1832 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s45) +Fast allSat, Looking for solution 1833 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s43) +Fast allSat, Looking for solution 1834 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s86) +Fast allSat, Looking for solution 1835 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s54) +Fast allSat, Looking for solution 1836 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s55) +Fast allSat, Looking for solution 1837 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s56) +Fast allSat, Looking for solution 1838 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s57) +Fast allSat, Looking for solution 1839 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s58) +[GOOD] (assert s59) +Fast allSat, Looking for solution 1839 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +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 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +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 s63) +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 s64) +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 s65) +Fast allSat, Looking for solution 1844 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +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 s67) +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 s68) +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 s69) +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 s70) +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 s71) +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 s88) +Fast allSat, Looking for solution 1851 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s72) +[GOOD] (assert s73) +Fast allSat, Looking for solution 1851 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 1852 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 1853 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1854 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 1855 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1856 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1857 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1858 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1859 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1860 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1861 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1862 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1863 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s58) +[GOOD] (assert s74) +Fast allSat, Looking for solution 1863 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1864 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[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 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[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 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1867 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1868 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 1869 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1870 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 1871 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[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 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1873 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1874 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1875 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s60) +[GOOD] (assert s75) +Fast allSat, Looking for solution 1875 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 1876 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 1877 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1878 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 1879 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1880 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1881 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1882 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1883 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1884 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1885 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1886 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +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 s71) +[GOOD] (assert s89) +Fast allSat, Looking for solution 1887 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1888 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[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 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1890 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1891 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[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 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[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 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[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 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[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 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1896 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1897 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1898 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1899 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s88) +[GOOD] (assert s85) +Fast allSat, Looking for solution 1899 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1900 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1901 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1902 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1903 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[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 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1905 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 1906 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 1907 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1908 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1909 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1910 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1911 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s71) +[GOOD] (assert s84) +Fast allSat, Looking for solution 1911 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 1912 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 1913 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1914 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 1915 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1916 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1917 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1918 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1919 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[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 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[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 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[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 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[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 s70) +[GOOD] (assert s83) +Fast allSat, Looking for solution 1923 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1924 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1925 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1926 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1927 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 1928 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1929 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 1930 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 1931 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1932 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1933 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1934 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1935 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s69) +[GOOD] (assert s82) +Fast allSat, Looking for solution 1935 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[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 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[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 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1938 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1939 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[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 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1941 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 1942 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 1943 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1944 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1945 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1946 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1947 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s68) +[GOOD] (assert s81) +Fast allSat, Looking for solution 1947 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1948 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1949 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1950 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1951 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 1952 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1953 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 1954 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 1955 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1956 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1957 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1958 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1959 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s67) +[GOOD] (assert s80) +Fast allSat, Looking for solution 1959 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[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 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[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 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[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 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1963 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1964 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 1965 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 1966 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 1967 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1968 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1969 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1970 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1971 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s66) +[GOOD] (assert s79) +Fast allSat, Looking for solution 1971 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1972 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1973 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1974 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1975 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1976 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1977 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 1978 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 1979 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1980 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1981 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1982 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1983 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s65) +[GOOD] (assert s78) +Fast allSat, Looking for solution 1983 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 1984 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 1985 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[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 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1987 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1988 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1989 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 1990 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 1991 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 1992 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 1993 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 1994 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 1995 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s64) +[GOOD] (assert s98) +[GOOD] (assert s77) +Fast allSat, Looking for solution 1995 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 1996 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 1997 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 1998 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 1999 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 2000 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 2001 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 2002 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 2003 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 2004 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 2005 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 2006 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 5)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 2007 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s53) +[GOOD] (define-fun s99 () Bool (= s0 s20)) +[GOOD] (assert s99) +Fast allSat, Looking for solution 2007 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s52) +Fast allSat, Looking for solution 2008 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s51) +Fast allSat, Looking for solution 2009 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s50) +Fast allSat, Looking for solution 2010 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s49) +Fast allSat, Looking for solution 2011 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s48) +Fast allSat, Looking for solution 2012 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s47) +Fast allSat, Looking for solution 2013 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s46) +Fast allSat, Looking for solution 2014 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s45) +Fast allSat, Looking for solution 2015 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s43) +Fast allSat, Looking for solution 2016 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s86) +Fast allSat, Looking for solution 2017 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s55) +Fast allSat, Looking for solution 2018 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s56) +Fast allSat, Looking for solution 2019 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s57) +Fast allSat, Looking for solution 2020 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s58) +[GOOD] (assert s59) +Fast allSat, Looking for solution 2020 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 2021 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 2022 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 2023 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 2024 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 2025 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 2026 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 2027 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 2028 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 2029 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2030 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 2031 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 2032 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s72) +[GOOD] (assert s73) +Fast allSat, Looking for solution 2032 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 2033 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 2034 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 2035 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 2036 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 2037 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 2038 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 2039 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 2040 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2041 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 2042 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 2043 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 2044 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s58) +[GOOD] (assert s74) +Fast allSat, Looking for solution 2044 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 2045 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[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 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 2047 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 2048 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 2049 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 2050 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 2051 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 2052 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 2053 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 2054 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 2055 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 2056 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s71) +[GOOD] (assert s89) +Fast allSat, Looking for solution 2056 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2057 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 2058 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 2059 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 2060 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 2061 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 2062 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[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 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 2064 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 2065 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 2066 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 2067 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 2068 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s88) +[GOOD] (assert s85) +Fast allSat, Looking for solution 2068 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2069 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 2070 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 2071 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 2072 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 2073 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 2074 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 2075 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[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 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 2077 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 2078 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 2079 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +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 s71) +[GOOD] (assert s84) +Fast allSat, Looking for solution 2080 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[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 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[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 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[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 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[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 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 2085 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[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 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 2087 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 2088 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 2089 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 2090 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 2091 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 2092 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s70) +[GOOD] (assert s83) +Fast allSat, Looking for solution 2092 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[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 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 2094 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 2095 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 2096 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 2097 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 2098 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 2099 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[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 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 2101 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 2102 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 2103 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 2104 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s69) +[GOOD] (assert s82) +Fast allSat, Looking for solution 2104 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2105 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 2106 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 2107 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[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 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 2109 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 2110 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 2111 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 2112 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 2113 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 2114 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 2115 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 2116 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s68) +[GOOD] (assert s81) +Fast allSat, Looking for solution 2116 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 2117 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[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 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 2119 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 2120 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 2121 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 2122 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 2123 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 2124 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 2125 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 2126 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 2127 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +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 s67) +[GOOD] (assert s80) +Fast allSat, Looking for solution 2128 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 2129 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 2130 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2131 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 2132 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 2133 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 2134 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 2135 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 2136 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 2137 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 2138 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 2139 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 2140 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s66) +[GOOD] (assert s79) +Fast allSat, Looking for solution 2140 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[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 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[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 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 2143 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 2144 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 2145 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 2146 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 2147 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 2148 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 2149 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 2150 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 2151 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 2152 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s65) +[GOOD] (assert s78) +Fast allSat, Looking for solution 2152 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[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 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 2154 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 2155 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 2156 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2157 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 2158 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 2159 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 2160 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 2161 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 2162 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 2163 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 2164 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s64) +[GOOD] (assert s77) +Fast allSat, Looking for solution 2164 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 2165 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[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 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 2167 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 2168 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 2169 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2170 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 2171 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 2172 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 2173 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 2174 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 2175 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 2176 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s63) +[GOOD] (assert s99) +[GOOD] (assert s76) +Fast allSat, Looking for solution 2176 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 2177 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2178 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 2179 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 2180 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 2181 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 2182 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 2183 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[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 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 2185 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 2186 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 2187 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 4)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 2188 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s54) +[GOOD] (define-fun s100 () Bool (= s0 s18)) +[GOOD] (assert s100) +Fast allSat, Looking for solution 2188 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s53) +Fast allSat, Looking for solution 2189 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s52) +Fast allSat, Looking for solution 2190 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s51) +Fast allSat, Looking for solution 2191 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s50) +Fast allSat, Looking for solution 2192 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s49) +Fast allSat, Looking for solution 2193 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s48) +Fast allSat, Looking for solution 2194 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s47) +Fast allSat, Looking for solution 2195 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s46) +Fast allSat, Looking for solution 2196 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s45) +Fast allSat, Looking for solution 2197 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s43) +Fast allSat, Looking for solution 2198 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s86) +Fast allSat, Looking for solution 2199 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s56) +Fast allSat, Looking for solution 2200 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s57) +Fast allSat, Looking for solution 2201 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s58) +[GOOD] (assert s59) +Fast allSat, Looking for solution 2201 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 2202 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 2203 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 2204 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 2205 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 2206 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 2207 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 2208 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 2209 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 2210 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2211 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 2212 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 2213 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s72) +[GOOD] (assert s73) +Fast allSat, Looking for solution 2213 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 2214 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 2215 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 2216 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 2217 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 2218 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 2219 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 2220 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 2221 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 2222 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2223 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 2224 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 2225 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s71) +[GOOD] (assert s89) +Fast allSat, Looking for solution 2225 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2226 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 2227 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 2228 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 2229 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 2230 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 2231 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 2232 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 2233 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 2234 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 2235 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 2236 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 2237 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s88) +[GOOD] (assert s85) +Fast allSat, Looking for solution 2237 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2238 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 2239 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 2240 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 2241 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 2242 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 2243 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 2244 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 2245 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 2246 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 2247 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 2248 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 2249 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s71) +[GOOD] (assert s84) +Fast allSat, Looking for solution 2249 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 2250 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 2251 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 2252 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 2253 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 2254 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 2255 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 2256 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 2257 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 2258 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 2259 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 2260 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 2261 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s70) +[GOOD] (assert s83) +Fast allSat, Looking for solution 2261 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 2262 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 2263 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 2264 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 2265 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 2266 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 2267 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 2268 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 2269 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 2270 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 2271 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 2272 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 2273 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s69) +[GOOD] (assert s82) +Fast allSat, Looking for solution 2273 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2274 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 2275 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 2276 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 2277 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 2278 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 2279 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 2280 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 2281 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 2282 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 2283 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 2284 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 2285 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s68) +[GOOD] (assert s81) +Fast allSat, Looking for solution 2285 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 2286 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2287 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 2288 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 2289 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 2290 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 2291 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 2292 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 2293 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 2294 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 2295 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 2296 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 2297 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s67) +[GOOD] (assert s80) +Fast allSat, Looking for solution 2297 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 2298 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 2299 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2300 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 2301 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 2302 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 2303 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 2304 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 2305 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 2306 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 2307 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 2308 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 2309 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s66) +[GOOD] (assert s79) +Fast allSat, Looking for solution 2309 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 2310 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 2311 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 2312 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2313 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 2314 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 2315 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 2316 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 2317 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 2318 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 2319 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 2320 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 2321 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s65) +[GOOD] (assert s78) +Fast allSat, Looking for solution 2321 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 2322 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 2323 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 2324 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 2325 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2326 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 2327 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 2328 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 2329 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 2330 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 2331 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 2332 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +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 s64) +[GOOD] (assert s77) +Fast allSat, Looking for solution 2333 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 2334 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 2335 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2336 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 2337 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 2338 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 2339 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 2340 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 2341 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 2342 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 2343 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 2344 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 2345 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s63) +[GOOD] (assert s76) +Fast allSat, Looking for solution 2345 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 2346 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 2347 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 2348 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 2349 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 2350 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 2351 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2352 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 2353 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 2354 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 2355 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 2356 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 2357 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s62) +[GOOD] (assert s100) +[GOOD] (assert s75) +Fast allSat, Looking for solution 2357 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 2358 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 2359 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2360 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 2361 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 2362 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 2363 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 2364 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 2365 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 2366 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 2367 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 2368 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 3)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 2369 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s55) +[GOOD] (define-fun s101 () Bool (= s0 s16)) +[GOOD] (assert s101) +Fast allSat, Looking for solution 2369 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s57) +Fast allSat, Looking for solution 2370 +[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 s54) +Fast allSat, Looking for solution 2371 +[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 s53) +Fast allSat, Looking for solution 2372 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s52) +Fast allSat, Looking for solution 2373 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s51) +Fast allSat, Looking for solution 2374 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s50) +Fast allSat, Looking for solution 2375 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s49) +Fast allSat, Looking for solution 2376 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s48) +Fast allSat, Looking for solution 2377 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s47) +Fast allSat, Looking for solution 2378 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s46) +Fast allSat, Looking for solution 2379 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s45) +Fast allSat, Looking for solution 2380 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s43) +Fast allSat, Looking for solution 2381 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s86) +Fast allSat, Looking for solution 2382 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s71) +[GOOD] (assert s89) +Fast allSat, Looking for solution 2382 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2383 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 2384 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 2385 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 2386 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 2387 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 2388 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 2389 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 2390 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 2391 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 2392 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 2393 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 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 s85) +Fast allSat, Looking for solution 2394 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 2395 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 2396 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 2397 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 2398 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 2399 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 2400 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 2401 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 2402 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 2403 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 2404 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 2405 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 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 s71) +[GOOD] (assert s84) +Fast allSat, Looking for solution 2406 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 2407 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 2408 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 2409 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 2410 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 2411 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 2412 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 2413 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 2414 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 2415 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 2416 +[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 2417 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 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 s70) +[GOOD] (assert s83) +Fast allSat, Looking for solution 2418 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 2419 +[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 2420 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 2421 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 2422 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 2423 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 2424 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 2425 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 2426 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 2427 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 2428 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 2429 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 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 s69) +[GOOD] (assert s82) +Fast allSat, Looking for solution 2430 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 2431 +[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 2432 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2433 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 2434 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 2435 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 2436 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 2437 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 2438 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 2439 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 2440 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 2441 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 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 s68) +[GOOD] (assert s81) +Fast allSat, Looking for solution 2442 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 2443 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2444 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 2445 +[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 2446 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 2447 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 2448 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 2449 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 2450 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 2451 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 2452 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 2453 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 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 s67) +[GOOD] (assert s80) +Fast allSat, Looking for solution 2454 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 2455 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 2456 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2457 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 2458 +[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 2459 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 2460 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 2461 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 2462 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 2463 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 2464 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 2465 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 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 s66) +[GOOD] (assert s79) +Fast allSat, Looking for solution 2466 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 2467 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 2468 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 2469 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2470 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 2471 +[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 2472 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 2473 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 2474 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 2475 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 2476 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 2477 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 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 s65) +[GOOD] (assert s78) +Fast allSat, Looking for solution 2478 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 2479 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 2480 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 2481 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 2482 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2483 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 2484 +[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 2485 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 2486 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 2487 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 2488 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 2489 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 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 s64) +[GOOD] (assert s77) +Fast allSat, Looking for solution 2490 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 2491 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 2492 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 2493 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 2494 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 2495 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2496 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 2497 +[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 2498 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 2499 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 2500 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 2501 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 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 s63) +[GOOD] (assert s76) +Fast allSat, Looking for solution 2502 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 2503 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 2504 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 2505 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 2506 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 2507 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 2508 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2509 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 2510 +[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 2511 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 2512 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 2513 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 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 s62) +[GOOD] (assert s75) +Fast allSat, Looking for solution 2514 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 2515 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 2516 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 2517 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 2518 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 2519 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 2520 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 2521 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2522 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 2523 +[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 2524 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 2525 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 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 s60) +[GOOD] (assert s59) +Fast allSat, Looking for solution 2526 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 2527 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 2528 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 2529 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 2530 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 2531 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 2532 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 2533 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 2534 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 2535 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2536 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 1)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 2537 +[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 2538 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s61) +[GOOD] (assert s101) +[GOOD] (assert s74) +Fast allSat, Looking for solution 2538 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 2539 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 2540 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 2541 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 2542 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 2543 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 2544 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 2545 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 2546 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2547 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 2548 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 2549 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 2)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 1)) +[GOOD] (push 1) +[GOOD] (assert s72) +Fast allSat, Looking for solution 2550 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s56) +[GOOD] (define-fun s102 () Bool (= s0 s3)) +[GOOD] (assert s102) +Fast allSat, Looking for solution 2550 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s55) +Fast allSat, Looking for solution 2551 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s54) +Fast allSat, Looking for solution 2552 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s53) +Fast allSat, Looking for solution 2553 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s52) +Fast allSat, Looking for solution 2554 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s51) +Fast allSat, Looking for solution 2555 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s50) +Fast allSat, Looking for solution 2556 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s49) +Fast allSat, Looking for solution 2557 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s48) +Fast allSat, Looking for solution 2558 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s47) +Fast allSat, Looking for solution 2559 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s46) +Fast allSat, Looking for solution 2560 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s45) +Fast allSat, Looking for solution 2561 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s43) +Fast allSat, Looking for solution 2562 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s86) +Fast allSat, Looking for solution 2563 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s71) +[GOOD] (assert s89) +Fast allSat, Looking for solution 2563 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2564 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 2565 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 2566 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 2567 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 2568 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 2569 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 2570 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 2571 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 2572 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 2573 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 2574 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 15)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 2575 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s88) +[GOOD] (assert s85) +Fast allSat, Looking for solution 2575 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 2576 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 2577 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 2578 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 2579 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 2580 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 2581 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 2582 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 2583 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 2584 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 2585 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 2586 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 14)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2587 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s71) +[GOOD] (assert s84) +Fast allSat, Looking for solution 2587 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 13)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +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 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +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 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +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 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +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 s66) +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 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +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 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +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 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +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 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +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 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +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 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +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 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 2599 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s70) +[GOOD] (assert s83) +Fast allSat, Looking for solution 2599 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +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 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 2601 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +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 s67) +Fast allSat, Looking for solution 2603 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert 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 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 2605 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 2606 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 2607 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 2608 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 2609 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 2610 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 12)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 2611 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s69) +[GOOD] (assert s82) +Fast allSat, Looking for solution 2611 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +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 s70) +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 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +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 s67) +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 s66) +Fast allSat, Looking for solution 2616 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 11)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +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 s64) +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 s63) +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 s62) +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 s61) +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 s60) +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 s58) +Fast allSat, Looking for solution 2623 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s68) +[GOOD] (assert s81) +Fast allSat, Looking for solution 2623 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +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 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2625 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 2626 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 2627 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 2628 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +Fast allSat, Looking for solution 2629 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 2630 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 2631 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 2632 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 2633 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 2634 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 10)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 2635 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s67) +[GOOD] (assert s80) +Fast allSat, Looking for solution 2635 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 9)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +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 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +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 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +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 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +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 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +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 s65) +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 s64) +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 s63) +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 s62) +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 s61) +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 s60) +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 s58) +Fast allSat, Looking for solution 2647 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s66) +[GOOD] (assert s79) +Fast allSat, Looking for solution 2647 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +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 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 2649 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 2650 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2651 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 2652 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 2653 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 2654 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 2655 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +Fast allSat, Looking for solution 2656 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +Fast allSat, Looking for solution 2657 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 2658 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 8)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 2659 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s65) +[GOOD] (assert s78) +Fast allSat, Looking for solution 2659 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 2660 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 2661 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 2662 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 2663 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2664 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 7)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +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 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +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 s63) +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 s62) +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 s61) +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 s60) +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 s58) +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 s64) +[GOOD] (assert s77) +Fast allSat, Looking for solution 2671 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +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 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 2673 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 2674 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 6)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +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 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +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 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +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 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +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 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +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 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +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 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +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 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +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 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +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 s63) +[GOOD] (assert s76) +Fast allSat, Looking for solution 2683 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +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 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +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 9)) +[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 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 2687 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 2688 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 2689 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2690 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 2691 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 2692 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 5)) +[SEND] (get-value (s2)) +[RECV] ((s2 4)) +[GOOD] (push 1) +[GOOD] (assert s61) +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 s60) +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 s58) +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 s62) +[GOOD] (assert s75) +Fast allSat, Looking for solution 2695 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +Fast allSat, Looking for solution 2696 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +Fast allSat, Looking for solution 2697 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +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 9)) +[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 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 2700 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 2701 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 2702 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2703 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 2704 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 2705 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 3)) +[GOOD] (push 1) +[GOOD] (assert s60) +Fast allSat, Looking for solution 2706 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 4)) +[SEND] (get-value (s2)) +[RECV] ((s2 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +Fast allSat, Looking for solution 2707 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s61) +[GOOD] (assert s74) +Fast allSat, Looking for solution 2707 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +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 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +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 2)) +[GOOD] (push 1) +[GOOD] (assert s58) +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 s64) +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 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 9)) +[GOOD] (push 1) +[GOOD] (assert s66) +Fast allSat, Looking for solution 2713 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +Fast allSat, Looking for solution 2714 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +Fast allSat, Looking for solution 2715 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +Fast allSat, Looking for solution 2716 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +Fast allSat, Looking for solution 2717 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +Fast allSat, Looking for solution 2718 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 3)) +[SEND] (get-value (s2)) +[RECV] ((s2 15)) +[GOOD] (push 1) +[GOOD] (assert s88) +Fast allSat, Looking for solution 2719 +[SEND] (check-sat) +[RECV] unsat +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (pop 1) +[GOOD] (push 1) +[GOOD] (assert s60) +[GOOD] (assert s102) +[GOOD] (assert s73) +Fast allSat, Looking for solution 2719 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (s0)) +[RECV] ((s0 1)) +[SEND] (get-value (s1)) +[RECV] ((s1 2)) +[SEND] (get-value (s2)) +[RECV] ((s2 14)) +[GOOD] (push 1) +[GOOD] (assert s71) +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 13)) +[GOOD] (push 1) +[GOOD] (assert s70) +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 12)) +[GOOD] (push 1) +[GOOD] (assert s69) +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 11)) +[GOOD] (push 1) +[GOOD] (assert s68) +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 10)) +[GOOD] (push 1) +[GOOD] (assert s67) +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 s66) +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 8)) +[GOOD] (push 1) +[GOOD] (assert s65) +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 7)) +[GOOD] (push 1) +[GOOD] (assert s64) +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 6)) +[GOOD] (push 1) +[GOOD] (assert s63) +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 5)) +[GOOD] (push 1) +[GOOD] (assert s62) +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 4)) +[GOOD] (push 1) +[GOOD] (assert s61) Fast allSat, Looking for solution 2730 [SEND] (check-sat) [RECV] sat diff --git a/SBVTestSuite/GoldFiles/array_misc_5.gold b/SBVTestSuite/GoldFiles/array_misc_5.gold --- a/SBVTestSuite/GoldFiles/array_misc_5.gold +++ b/SBVTestSuite/GoldFiles/array_misc_5.gold @@ -5,25 +5,19 @@ [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) ; NB. User specified. [GOOD] ; --- tuples --- [GOOD] ; --- sums --- [GOOD] ; --- literal constants --- -[GOOD] (define-fun s0 () (Array (_ BitVec 2) (_ BitVec 2)) (store (store (store (store ((as const (Array (_ BitVec 2) (_ BitVec 2))) #b00) #b11 #b11) #b10 #b10) #b01 #b01) #b00 #b00)) -[GOOD] (define-fun s1 () (Array (_ BitVec 2) (_ BitVec 2)) (store (store (store (store ((as const (Array (_ BitVec 2) (_ BitVec 2))) #b01) #b11 #b11) #b10 #b10) #b01 #b01) #b00 #b00)) [GOOD] ; --- top level inputs --- [GOOD] ; --- constant tables --- [GOOD] ; --- non-constant tables --- [GOOD] ; --- uninterpreted constants --- [GOOD] ; --- user defined functions --- [GOOD] ; --- assignments --- -[GOOD] (define-fun s2 () Bool (= s0 s1)) [GOOD] ; --- delayedEqualities --- [GOOD] ; --- formula --- -[GOOD] (assert (not s2)) +[GOOD] (assert false) [SEND] (check-sat) [RECV] unsat *** Solver : Z3 diff --git a/SBVTestSuite/GoldFiles/charConstr00.gold b/SBVTestSuite/GoldFiles/charConstr00.gold --- a/SBVTestSuite/GoldFiles/charConstr00.gold +++ b/SBVTestSuite/GoldFiles/charConstr00.gold @@ -27,6 +27,6 @@ [SEND] (get-value (s0)) [RECV] ((s0 "B")) -MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [("x",'B' :: Char)], modelUIFuns = []} +MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [("x",'B' :: Char)], modelUIFuns = [], modelUIBindings = Nothing} DONE.*** Solver : Z3 *** Exit code: ExitSuccess diff --git a/SBVTestSuite/GoldFiles/charConstr01.gold b/SBVTestSuite/GoldFiles/charConstr01.gold --- a/SBVTestSuite/GoldFiles/charConstr01.gold +++ b/SBVTestSuite/GoldFiles/charConstr01.gold @@ -35,6 +35,6 @@ [SEND] (get-value (cf)) [RECV] ((cf ((as const (Array Int String)) "B"))) -MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [], modelUIFuns = [("cf",(True,SInteger -> SChar,Right ([],'B' :: Char)))]} +MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [], modelUIFuns = [("cf",(True,SInteger -> SChar,Right ([],'B' :: Char)))], modelUIBindings = Nothing} DONE.*** Solver : Z3 *** Exit code: ExitSuccess diff --git a/SBVTestSuite/GoldFiles/charConstr02.gold b/SBVTestSuite/GoldFiles/charConstr02.gold --- a/SBVTestSuite/GoldFiles/charConstr02.gold +++ b/SBVTestSuite/GoldFiles/charConstr02.gold @@ -46,6 +46,6 @@ [RECV] ((cf3 ((as const (Array Int (SBVTuple3 String String String))) (mkSBVTuple3 "A" "A" "A")))) -MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [], modelUIFuns = [("cf3",(True,SInteger -> (SChar, SChar, SChar),Right ([],('A','A','A') :: (Char, Char, Char))))]} +MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [], modelUIFuns = [("cf3",(True,SInteger -> (SChar, SChar, SChar),Right ([],('A','A','A') :: (Char, Char, Char))))], modelUIBindings = Nothing} DONE.*** Solver : Z3 *** Exit code: ExitSuccess diff --git a/SBVTestSuite/GoldFiles/charConstr03.gold b/SBVTestSuite/GoldFiles/charConstr03.gold --- a/SBVTestSuite/GoldFiles/charConstr03.gold +++ b/SBVTestSuite/GoldFiles/charConstr03.gold @@ -38,6 +38,6 @@ [SEND] (get-value (s0)) [RECV] ((s0 (Left "B"))) -MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [("x",Left 'B' :: Either Char Char)], modelUIFuns = []} +MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [("x",Left 'B' :: Either Char Char)], modelUIFuns = [], modelUIBindings = Nothing} DONE.*** Solver : Z3 *** Exit code: ExitSuccess diff --git a/SBVTestSuite/GoldFiles/charConstr04.gold b/SBVTestSuite/GoldFiles/charConstr04.gold --- a/SBVTestSuite/GoldFiles/charConstr04.gold +++ b/SBVTestSuite/GoldFiles/charConstr04.gold @@ -36,6 +36,6 @@ [SEND] (get-value (s0)) [RECV] ((s0 (Left 2))) -MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [("x",Left 2 :: Either Integer Char)], modelUIFuns = []} +MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [("x",Left 2 :: Either Integer Char)], modelUIFuns = [], modelUIBindings = Nothing} DONE.*** Solver : Z3 *** Exit code: ExitSuccess diff --git a/SBVTestSuite/GoldFiles/charConstr05.gold b/SBVTestSuite/GoldFiles/charConstr05.gold --- a/SBVTestSuite/GoldFiles/charConstr05.gold +++ b/SBVTestSuite/GoldFiles/charConstr05.gold @@ -36,6 +36,6 @@ [SEND] (get-value (s0)) [RECV] ((s0 (Left "B"))) -MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [("x",Left 'B' :: Either Char Integer)], modelUIFuns = []} +MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [("x",Left 'B' :: Either Char Integer)], modelUIFuns = [], modelUIBindings = Nothing} DONE.*** Solver : Z3 *** Exit code: ExitSuccess diff --git a/SBVTestSuite/GoldFiles/charConstr06.gold b/SBVTestSuite/GoldFiles/charConstr06.gold --- a/SBVTestSuite/GoldFiles/charConstr06.gold +++ b/SBVTestSuite/GoldFiles/charConstr06.gold @@ -38,6 +38,6 @@ [SEND] (get-value (s0)) [RECV] ((s0 ((as Left (Either String (Either String Int))) "B"))) -MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [("x",Left 'B' :: Either Char (Either Char Integer))], modelUIFuns = []} +MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [("x",Left 'B' :: Either Char (Either Char Integer))], modelUIFuns = [], modelUIBindings = Nothing} DONE.*** Solver : Z3 *** Exit code: ExitSuccess diff --git a/SBVTestSuite/GoldFiles/charConstr07.gold b/SBVTestSuite/GoldFiles/charConstr07.gold --- a/SBVTestSuite/GoldFiles/charConstr07.gold +++ b/SBVTestSuite/GoldFiles/charConstr07.gold @@ -38,6 +38,6 @@ [SEND] (get-value (s0)) [RECV] ((s0 (Just "B"))) -MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [("x",Just 'B' :: Maybe Char)], modelUIFuns = []} +MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [("x",Just 'B' :: Maybe Char)], modelUIFuns = [], modelUIBindings = Nothing} DONE.*** Solver : Z3 *** Exit code: ExitSuccess diff --git a/SBVTestSuite/GoldFiles/charConstr08.gold b/SBVTestSuite/GoldFiles/charConstr08.gold --- a/SBVTestSuite/GoldFiles/charConstr08.gold +++ b/SBVTestSuite/GoldFiles/charConstr08.gold @@ -34,6 +34,6 @@ [SEND] (get-value (s0)) [RECV] ((s0 (lambda ((x!1 String)) (= x!1 "A")))) -MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [("x",{'A'} :: {Char})], modelUIFuns = []} +MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [("x",{'A'} :: {Char})], modelUIFuns = [], modelUIBindings = Nothing} DONE.*** Solver : Z3 *** Exit code: ExitSuccess diff --git a/SBVTestSuite/GoldFiles/charConstr09.gold b/SBVTestSuite/GoldFiles/charConstr09.gold --- a/SBVTestSuite/GoldFiles/charConstr09.gold +++ b/SBVTestSuite/GoldFiles/charConstr09.gold @@ -34,6 +34,6 @@ [SEND] (get-value (s0)) [RECV] ((s0 (seq.unit (mkSBVTuple2 (mkSBVTuple2 "A" "A") (seq.unit 2))))) -MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [("x",[(('A','A'),[2])] :: [((Char, Char), [Integer])])], modelUIFuns = []} +MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [("x",[(('A','A'),[2])] :: [((Char, Char), [Integer])])], modelUIFuns = [], modelUIBindings = Nothing} DONE.*** Solver : Z3 *** Exit code: ExitSuccess diff --git a/SBVTestSuite/GoldFiles/charConstr10.gold b/SBVTestSuite/GoldFiles/charConstr10.gold --- a/SBVTestSuite/GoldFiles/charConstr10.gold +++ b/SBVTestSuite/GoldFiles/charConstr10.gold @@ -41,6 +41,6 @@ [SEND] (get-value (s0)) [RECV] ((s0 (seq.unit (mkSBVTuple2 (mkSBVTuple2 "B" "B") (seq.unit 2))))) -MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [("x",[(('B','B'),[2])] :: [((Char, Char), [Integer])])], modelUIFuns = []} +MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [("x",[(('B','B'),[2])] :: [((Char, Char), [Integer])])], modelUIFuns = [], modelUIBindings = Nothing} DONE.*** Solver : Z3 *** Exit code: ExitSuccess diff --git a/SBVTestSuite/GoldFiles/charConstr11.gold b/SBVTestSuite/GoldFiles/charConstr11.gold --- a/SBVTestSuite/GoldFiles/charConstr11.gold +++ b/SBVTestSuite/GoldFiles/charConstr11.gold @@ -50,6 +50,6 @@ (Array Int String (Seq (SBVTuple2 (SBVTuple2 String String) (Seq Int))))) (seq.unit (mkSBVTuple2 (mkSBVTuple2 "A" "A") (seq.unit 2)))))) -MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [("x",3 :: Integer),("c",'A' :: Char)], modelUIFuns = [("cf4",(True,SInteger -> SChar -> [((SChar, SChar), [SInteger])],Right ([],[(('A','A'),[2])] :: [((Char, Char), [Integer])])))]} +MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [("x",3 :: Integer),("c",'A' :: Char)], modelUIFuns = [("cf4",(True,SInteger -> SChar -> [((SChar, SChar), [SInteger])],Right ([],[(('A','A'),[2])] :: [((Char, Char), [Integer])])))], modelUIBindings = Nothing} DONE.*** Solver : Z3 *** Exit code: ExitSuccess diff --git a/SBVTestSuite/GoldFiles/doctest_sanity.gold b/SBVTestSuite/GoldFiles/doctest_sanity.gold --- a/SBVTestSuite/GoldFiles/doctest_sanity.gold +++ b/SBVTestSuite/GoldFiles/doctest_sanity.gold @@ -1,3 +1,3 @@ -Total: 1268; Tried: 1268; Skipped: 0; Success: 1268; Errors: 0; Failures 0 -Examples: 1113; Tried: 1113; Skipped: 0; Success: 1113; Errors: 0; Failures 0 -Setup: 155; Tried: 155; Skipped: 0; Success: 155; Errors: 0; Failures 0 +Total: 1409; Tried: 1409; Skipped: 0; Success: 1409; Errors: 0; Failures 0 +Examples: 1252; Tried: 1252; Skipped: 0; Success: 1252; Errors: 0; Failures 0 +Setup: 157; Tried: 157; Skipped: 0; Success: 157; Errors: 0; Failures 0 diff --git a/SBVTestSuite/GoldFiles/lambda15.gold b/SBVTestSuite/GoldFiles/lambda15.gold --- a/SBVTestSuite/GoldFiles/lambda15.gold +++ b/SBVTestSuite/GoldFiles/lambda15.gold @@ -101,19 +101,19 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (s14)) -[RECV] ((s14 8946)) +[RECV] ((s14 15922)) [SEND] (get-value (s16)) -[RECV] ((s16 8946)) +[RECV] ((s16 15922)) [SEND] (get-value (s0)) -[RECV] ((s0 (mkSBVTuple2 8946 (seq.unit 0)))) +[RECV] ((s0 (mkSBVTuple2 15922 (seq.unit 0)))) [SEND] (get-value (s12)) [RECV] ((s12 0)) *** Solver : Z3 *** Exit code: ExitSuccess [MEASURE] sbv.foldl @(SBV (Integer,Integer) -> SBV Integer)_1fd06f7602 @(SBV (Integer,[Integer]) -> SBV Integer): abs arg1._1 failed strict decrease: Falsifiable. Counter-example: - arg = (8946,[0]) :: (Integer, [Integer]) - before = 8946 :: Integer - then = 8946 :: Integer + arg = (15922,[0]) :: (Integer, [Integer]) + before = 15922 :: Integer + then = 15922 :: Integer [MEASURE] sbv.foldl @(SBV (Integer,Integer) -> SBV Integer)_1fd06f7602 @(SBV (Integer,[Integer]) -> SBV Integer): trying next candidate.. [MEASURE] sbv.foldl @(SBV (Integer,Integer) -> SBV Integer)_1fd06f7602 @(SBV (Integer,[Integer]) -> SBV Integer): trying length arg1._2 [MEASURE] replayDAG {sbv.foldl @(SBV (Integer,Integer) -> SBV Integer)_1fd06f7602 @(SBV (Integer,[Integer]) -> SBV Integer)}: replaying 11 node(s) diff --git a/SBVTestSuite/GoldFiles/lambda69.gold b/SBVTestSuite/GoldFiles/lambda69.gold --- a/SBVTestSuite/GoldFiles/lambda69.gold +++ b/SBVTestSuite/GoldFiles/lambda69.gold @@ -34,11 +34,11 @@ [GOOD] (set-option :pp.min_alias_size 4294967295) [GOOD] (set-option :model.inline_def true ) [SEND] (get-value (F)) -[RECV] ((F (lambda ((x!1 Int) (x!2 Int)) (+ 3 (* (- 1) x!2) (* 2 x!1))))) +[RECV] ((F (lambda ((x!1 Int) (x!2 Int)) (+ 3 (* 2 x!1) (* (- 1) x!2))))) *** Solver : Z3 *** Exit code: ExitSuccess RESULT: Satisfiable. Model: F :: Integer -> Integer -> Integer - F x y = 3 + (-y) + 2 * x + F x y = 3 + 2 * x + (-y) diff --git a/SBVTestSuite/GoldFiles/pareto1.gold b/SBVTestSuite/GoldFiles/pareto1.gold --- a/SBVTestSuite/GoldFiles/pareto1.gold +++ b/SBVTestSuite/GoldFiles/pareto1.gold @@ -17,164 +17,164 @@ max_x_plus_y = 4 :: Integer min_y = 4 :: Integer Pareto front #4: Optimal model: - x = 3 :: Integer - y = 2 :: Integer - min_x = 3 :: Integer - max_x_plus_y = 5 :: Integer - min_y = 2 :: Integer -Pareto front #5: Optimal model: x = 2 :: Integer - y = 1 :: Integer + y = 4 :: Integer min_x = 2 :: Integer - max_x_plus_y = 3 :: Integer - min_y = 1 :: Integer -Pareto front #6: Optimal model: + max_x_plus_y = 6 :: Integer + min_y = 4 :: Integer +Pareto front #5: Optimal model: x = 3 :: Integer - y = 1 :: Integer + y = 4 :: Integer min_x = 3 :: Integer - max_x_plus_y = 4 :: Integer - min_y = 1 :: Integer -Pareto front #7: Optimal model: + max_x_plus_y = 7 :: Integer + min_y = 4 :: Integer +Pareto front #6: Optimal model: x = 4 :: Integer - y = 0 :: Integer + y = 4 :: Integer min_x = 4 :: Integer - max_x_plus_y = 4 :: Integer - min_y = 0 :: Integer + max_x_plus_y = 8 :: Integer + min_y = 4 :: Integer +Pareto front #7: Optimal model: + x = 2 :: Integer + y = 3 :: Integer + min_x = 2 :: Integer + max_x_plus_y = 5 :: Integer + min_y = 3 :: Integer Pareto front #8: Optimal model: + x = 1 :: Integer + y = 2 :: Integer + min_x = 1 :: Integer + max_x_plus_y = 3 :: Integer + min_y = 2 :: Integer +Pareto front #9: Optimal model: x = 2 :: Integer y = 2 :: Integer min_x = 2 :: Integer max_x_plus_y = 4 :: Integer min_y = 2 :: Integer -Pareto front #9: Optimal model: +Pareto front #10: Optimal model: + x = 5 :: Integer + y = 1 :: Integer + min_x = 5 :: Integer + max_x_plus_y = 6 :: Integer + min_y = 1 :: Integer +Pareto front #11: Optimal model: x = 1 :: Integer y = 3 :: Integer min_x = 1 :: Integer max_x_plus_y = 4 :: Integer min_y = 3 :: Integer -Pareto front #10: Optimal model: - x = 0 :: Integer - y = 0 :: Integer - min_x = 0 :: Integer - max_x_plus_y = 0 :: Integer - min_y = 0 :: Integer -Pareto front #11: Optimal model: - x = 0 :: Integer +Pareto front #12: Optimal model: + x = 4 :: Integer y = 1 :: Integer - min_x = 0 :: Integer - max_x_plus_y = 1 :: Integer + min_x = 4 :: Integer + max_x_plus_y = 5 :: Integer min_y = 1 :: Integer -Pareto front #12: Optimal model: - x = 2 :: Integer +Pareto front #13: Optimal model: + x = 5 :: Integer y = 0 :: Integer - min_x = 2 :: Integer - max_x_plus_y = 2 :: Integer + min_x = 5 :: Integer + max_x_plus_y = 5 :: Integer min_y = 0 :: Integer -Pareto front #13: Optimal model: - x = 0 :: Integer - y = 2 :: Integer - min_x = 0 :: Integer - max_x_plus_y = 2 :: Integer - min_y = 2 :: Integer Pareto front #14: Optimal model: x = 3 :: Integer - y = 0 :: Integer + y = 3 :: Integer min_x = 3 :: Integer - max_x_plus_y = 3 :: Integer - min_y = 0 :: Integer + max_x_plus_y = 6 :: Integer + min_y = 3 :: Integer Pareto front #15: Optimal model: - x = 1 :: Integer + x = 5 :: Integer y = 2 :: Integer - min_x = 1 :: Integer - max_x_plus_y = 3 :: Integer + min_x = 5 :: Integer + max_x_plus_y = 7 :: Integer min_y = 2 :: Integer Pareto front #16: Optimal model: + x = 4 :: Integer + y = 3 :: Integer + min_x = 4 :: Integer + max_x_plus_y = 7 :: Integer + min_y = 3 :: Integer +Pareto front #17: Optimal model: + x = 5 :: Integer + y = 3 :: Integer + min_x = 5 :: Integer + max_x_plus_y = 8 :: Integer + min_y = 3 :: Integer +Pareto front #18: Optimal model: + x = 5 :: Integer + y = 4 :: Integer + min_x = 5 :: Integer + max_x_plus_y = 9 :: Integer + min_y = 4 :: Integer +Pareto front #19: Optimal model: + x = 0 :: Integer + y = 0 :: Integer + min_x = 0 :: Integer + max_x_plus_y = 0 :: Integer + min_y = 0 :: Integer +Pareto front #20: Optimal model: x = 1 :: Integer y = 0 :: Integer min_x = 1 :: Integer max_x_plus_y = 1 :: Integer min_y = 0 :: Integer -Pareto front #17: Optimal model: - x = 5 :: Integer - y = 0 :: Integer - min_x = 5 :: Integer - max_x_plus_y = 5 :: Integer - min_y = 0 :: Integer -Pareto front #18: Optimal model: - x = 4 :: Integer +Pareto front #21: Optimal model: + x = 0 :: Integer y = 1 :: Integer - min_x = 4 :: Integer - max_x_plus_y = 5 :: Integer + min_x = 0 :: Integer + max_x_plus_y = 1 :: Integer min_y = 1 :: Integer -Pareto front #19: Optimal model: - x = 5 :: Integer +Pareto front #22: Optimal model: + x = 3 :: Integer + y = 0 :: Integer + min_x = 3 :: Integer + max_x_plus_y = 3 :: Integer + min_y = 0 :: Integer +Pareto front #23: Optimal model: + x = 2 :: Integer + y = 0 :: Integer + min_x = 2 :: Integer + max_x_plus_y = 2 :: Integer + min_y = 0 :: Integer +Pareto front #24: Optimal model: + x = 2 :: Integer y = 1 :: Integer - min_x = 5 :: Integer - max_x_plus_y = 6 :: Integer + min_x = 2 :: Integer + max_x_plus_y = 3 :: Integer min_y = 1 :: Integer -Pareto front #20: Optimal model: +Pareto front #25: Optimal model: x = 1 :: Integer y = 4 :: Integer min_x = 1 :: Integer max_x_plus_y = 5 :: Integer min_y = 4 :: Integer -Pareto front #21: Optimal model: - x = 4 :: Integer +Pareto front #26: Optimal model: + x = 0 :: Integer y = 2 :: Integer - min_x = 4 :: Integer - max_x_plus_y = 6 :: Integer + min_x = 0 :: Integer + max_x_plus_y = 2 :: Integer min_y = 2 :: Integer -Pareto front #22: Optimal model: - x = 4 :: Integer - y = 3 :: Integer - min_x = 4 :: Integer - max_x_plus_y = 7 :: Integer - min_y = 3 :: Integer -Pareto front #23: Optimal model: +Pareto front #27: Optimal model: x = 3 :: Integer - y = 4 :: Integer - min_x = 3 :: Integer - max_x_plus_y = 7 :: Integer - min_y = 4 :: Integer -Pareto front #24: Optimal model: - x = 5 :: Integer y = 2 :: Integer - min_x = 5 :: Integer - max_x_plus_y = 7 :: Integer + min_x = 3 :: Integer + max_x_plus_y = 5 :: Integer min_y = 2 :: Integer -Pareto front #25: Optimal model: +Pareto front #28: Optimal model: x = 3 :: Integer - y = 3 :: Integer + y = 1 :: Integer min_x = 3 :: Integer - max_x_plus_y = 6 :: Integer - min_y = 3 :: Integer -Pareto front #26: Optimal model: - x = 5 :: Integer - y = 3 :: Integer - min_x = 5 :: Integer - max_x_plus_y = 8 :: Integer - min_y = 3 :: Integer -Pareto front #27: Optimal model: + max_x_plus_y = 4 :: Integer + min_y = 1 :: Integer +Pareto front #29: Optimal model: x = 4 :: Integer - y = 4 :: Integer + y = 2 :: Integer min_x = 4 :: Integer - max_x_plus_y = 8 :: Integer - min_y = 4 :: Integer -Pareto front #28: Optimal model: - x = 2 :: Integer - y = 4 :: Integer - min_x = 2 :: Integer max_x_plus_y = 6 :: Integer - min_y = 4 :: Integer -Pareto front #29: Optimal model: - x = 5 :: Integer - y = 4 :: Integer - min_x = 5 :: Integer - max_x_plus_y = 9 :: Integer - min_y = 4 :: Integer + min_y = 2 :: Integer Pareto front #30: Optimal model: - x = 2 :: Integer - y = 3 :: Integer - min_x = 2 :: Integer - max_x_plus_y = 5 :: Integer - min_y = 3 :: Integer + x = 4 :: Integer + y = 0 :: Integer + min_x = 4 :: Integer + max_x_plus_y = 4 :: Integer + min_y = 0 :: Integer diff --git a/SBVTestSuite/GoldFiles/pareto2.gold b/SBVTestSuite/GoldFiles/pareto2.gold --- a/SBVTestSuite/GoldFiles/pareto2.gold +++ b/SBVTestSuite/GoldFiles/pareto2.gold @@ -1,182 +1,182 @@ Pareto front #1: Optimal model: - x = 0 :: Integer - y = 1 :: Integer - min_x = 0 :: Integer - max_y = 1 :: Integer - max_x_plus_y = 1 :: Integer -Pareto front #2: Optimal model: - x = 0 :: Integer - y = 2 :: Integer - min_x = 0 :: Integer - max_y = 2 :: Integer - max_x_plus_y = 2 :: Integer -Pareto front #3: Optimal model: - x = 0 :: Integer - y = 3 :: Integer - min_x = 0 :: Integer - max_y = 3 :: Integer - max_x_plus_y = 3 :: Integer -Pareto front #4: Optimal model: - x = 0 :: Integer - y = 5 :: Integer - min_x = 0 :: Integer - max_y = 5 :: Integer - max_x_plus_y = 5 :: Integer -Pareto front #5: Optimal model: - x = 0 :: Integer - y = 7 :: Integer - min_x = 0 :: Integer - max_y = 7 :: Integer - max_x_plus_y = 7 :: Integer -Pareto front #6: Optimal model: - x = 0 :: Integer - y = 6 :: Integer - min_x = 0 :: Integer - max_y = 6 :: Integer - max_x_plus_y = 6 :: Integer -Pareto front #7: Optimal model: - x = 0 :: Integer - y = 0 :: Integer - min_x = 0 :: Integer - max_y = 0 :: Integer - max_x_plus_y = 0 :: Integer -Pareto front #8: Optimal model: x = 0 :: Integer - y = -2 :: Integer + y = -1 :: Integer min_x = 0 :: Integer - max_y = -2 :: Integer - max_x_plus_y = -2 :: Integer -Pareto front #9: Optimal model: + max_y = -1 :: Integer + max_x_plus_y = -1 :: Integer +Pareto front #2: Optimal model: x = 0 :: Integer - y = -4 :: Integer + y = -3 :: Integer min_x = 0 :: Integer - max_y = -4 :: Integer - max_x_plus_y = -4 :: Integer -Pareto front #10: Optimal model: + max_y = -3 :: Integer + max_x_plus_y = -3 :: Integer +Pareto front #3: Optimal model: x = 0 :: Integer y = -5 :: Integer min_x = 0 :: Integer max_y = -5 :: Integer max_x_plus_y = -5 :: Integer -Pareto front #11: Optimal model: - x = 0 :: Integer - y = -6 :: Integer - min_x = 0 :: Integer - max_y = -6 :: Integer - max_x_plus_y = -6 :: Integer -Pareto front #12: Optimal model: +Pareto front #4: Optimal model: x = 0 :: Integer - y = -8 :: Integer + y = -7 :: Integer min_x = 0 :: Integer - max_y = -8 :: Integer - max_x_plus_y = -8 :: Integer -Pareto front #13: Optimal model: + max_y = -7 :: Integer + max_x_plus_y = -7 :: Integer +Pareto front #5: Optimal model: x = 0 :: Integer y = -9 :: Integer min_x = 0 :: Integer max_y = -9 :: Integer max_x_plus_y = -9 :: Integer -Pareto front #14: Optimal model: +Pareto front #6: Optimal model: x = 0 :: Integer + y = -10 :: Integer + min_x = 0 :: Integer + max_y = -10 :: Integer + max_x_plus_y = -10 :: Integer +Pareto front #7: Optimal model: + x = 0 :: Integer y = -11 :: Integer min_x = 0 :: Integer max_y = -11 :: Integer max_x_plus_y = -11 :: Integer -Pareto front #15: Optimal model: +Pareto front #8: Optimal model: x = 0 :: Integer y = -13 :: Integer min_x = 0 :: Integer max_y = -13 :: Integer max_x_plus_y = -13 :: Integer -Pareto front #16: Optimal model: +Pareto front #9: Optimal model: x = 0 :: Integer y = -15 :: Integer min_x = 0 :: Integer max_y = -15 :: Integer max_x_plus_y = -15 :: Integer -Pareto front #17: Optimal model: +Pareto front #10: Optimal model: x = 0 :: Integer y = -16 :: Integer min_x = 0 :: Integer max_y = -16 :: Integer max_x_plus_y = -16 :: Integer -Pareto front #18: Optimal model: +Pareto front #11: Optimal model: x = 0 :: Integer y = -18 :: Integer min_x = 0 :: Integer max_y = -18 :: Integer max_x_plus_y = -18 :: Integer -Pareto front #19: Optimal model: - x = 0 :: Integer - y = -19 :: Integer - min_x = 0 :: Integer - max_y = -19 :: Integer - max_x_plus_y = -19 :: Integer -Pareto front #20: Optimal model: +Pareto front #12: Optimal model: x = 0 :: Integer y = -20 :: Integer min_x = 0 :: Integer max_y = -20 :: Integer max_x_plus_y = -20 :: Integer -Pareto front #21: Optimal model: +Pareto front #13: Optimal model: x = 0 :: Integer y = -22 :: Integer min_x = 0 :: Integer max_y = -22 :: Integer max_x_plus_y = -22 :: Integer -Pareto front #22: Optimal model: +Pareto front #14: Optimal model: x = 0 :: Integer + y = -23 :: Integer + min_x = 0 :: Integer + max_y = -23 :: Integer + max_x_plus_y = -23 :: Integer +Pareto front #15: Optimal model: + x = 0 :: Integer y = -24 :: Integer min_x = 0 :: Integer max_y = -24 :: Integer max_x_plus_y = -24 :: Integer -Pareto front #23: Optimal model: +Pareto front #16: Optimal model: x = 0 :: Integer - y = -25 :: Integer + y = -26 :: Integer min_x = 0 :: Integer - max_y = -25 :: Integer - max_x_plus_y = -25 :: Integer -Pareto front #24: Optimal model: + max_y = -26 :: Integer + max_x_plus_y = -26 :: Integer +Pareto front #17: Optimal model: x = 0 :: Integer y = -27 :: Integer min_x = 0 :: Integer max_y = -27 :: Integer max_x_plus_y = -27 :: Integer -Pareto front #25: Optimal model: +Pareto front #18: Optimal model: x = 0 :: Integer y = -28 :: Integer min_x = 0 :: Integer max_y = -28 :: Integer max_x_plus_y = -28 :: Integer -Pareto front #26: Optimal model: +Pareto front #19: Optimal model: x = 0 :: Integer y = -30 :: Integer min_x = 0 :: Integer max_y = -30 :: Integer max_x_plus_y = -30 :: Integer -Pareto front #27: Optimal model: +Pareto front #20: Optimal model: x = 0 :: Integer - y = -32 :: Integer + y = -31 :: Integer min_x = 0 :: Integer - max_y = -32 :: Integer - max_x_plus_y = -32 :: Integer -Pareto front #28: Optimal model: + max_y = -31 :: Integer + max_x_plus_y = -31 :: Integer +Pareto front #21: Optimal model: x = 0 :: Integer y = -33 :: Integer min_x = 0 :: Integer max_y = -33 :: Integer max_x_plus_y = -33 :: Integer -Pareto front #29: Optimal model: +Pareto front #22: Optimal model: x = 0 :: Integer + y = -34 :: Integer + min_x = 0 :: Integer + max_y = -34 :: Integer + max_x_plus_y = -34 :: Integer +Pareto front #23: Optimal model: + x = 0 :: Integer y = -35 :: Integer min_x = 0 :: Integer max_y = -35 :: Integer max_x_plus_y = -35 :: Integer +Pareto front #24: Optimal model: + x = 0 :: Integer + y = -36 :: Integer + min_x = 0 :: Integer + max_y = -36 :: Integer + max_x_plus_y = -36 :: Integer +Pareto front #25: Optimal model: + x = 0 :: Integer + y = -38 :: Integer + min_x = 0 :: Integer + max_y = -38 :: Integer + max_x_plus_y = -38 :: Integer +Pareto front #26: Optimal model: + x = 0 :: Integer + y = -39 :: Integer + min_x = 0 :: Integer + max_y = -39 :: Integer + max_x_plus_y = -39 :: Integer +Pareto front #27: Optimal model: + x = 0 :: Integer + y = -41 :: Integer + min_x = 0 :: Integer + max_y = -41 :: Integer + max_x_plus_y = -41 :: Integer +Pareto front #28: Optimal model: + x = 0 :: Integer + y = -43 :: Integer + min_x = 0 :: Integer + max_y = -43 :: Integer + max_x_plus_y = -43 :: Integer +Pareto front #29: Optimal model: + x = 0 :: Integer + y = -44 :: Integer + min_x = 0 :: Integer + max_y = -44 :: Integer + max_x_plus_y = -44 :: Integer Pareto front #30: Optimal model: x = 0 :: Integer - y = -37 :: Integer + y = -46 :: Integer min_x = 0 :: Integer - max_y = -37 :: Integer - max_x_plus_y = -37 :: Integer + max_y = -46 :: Integer + max_x_plus_y = -46 :: Integer *** Note: Pareto-front extraction was terminated as requested by the user. *** There might be many other results! diff --git a/SBVTestSuite/GoldFiles/qOpt_1.gold b/SBVTestSuite/GoldFiles/qOpt_1.gold --- a/SBVTestSuite/GoldFiles/qOpt_1.gold +++ b/SBVTestSuite/GoldFiles/qOpt_1.gold @@ -54,7 +54,7 @@ [SEND] (get-objectives) [RECV] (objectives (s3 oo) - (s6 (interval (* (- 1) oo) oo)) + (s6 (interval 111 oo)) (s9 (interval (* (- 1) oo) oo)) (s12 (interval (* (- 1) oo) oo)) (s15 (interval (* (- 1) oo) oo)) @@ -62,7 +62,7 @@ [SEND] (get-value (s0)) [RECV] ((s0 1)) [SEND] (get-value (s4)) -[RECV] ((s4 1)) +[RECV] ((s4 111)) [SEND] (get-value (s7)) [RECV] ((s7 1)) [SEND] (get-value (s10)) @@ -72,7 +72,7 @@ [SEND] (get-value (s3)) [RECV] ((s3 1)) [SEND] (get-value (s6)) -[RECV] ((s6 1)) +[RECV] ((s6 111)) [SEND] (get-value (s9)) [RECV] ((s9 1)) [SEND] (get-value (s12)) @@ -82,7 +82,7 @@ [SEND] (get-objectives) [RECV] (objectives (s3 oo) - (s6 (interval (* (- 1) oo) oo)) + (s6 (interval 111 oo)) (s9 (interval (* (- 1) oo) oo)) (s12 (interval (* (- 1) oo) oo)) (s15 (interval (* (- 1) oo) oo)) @@ -102,7 +102,7 @@ *** *** Optimal in an extension field: *** goal1 = oo :: Integer -*** goal2 = [-oo .. oo] :: [Integer] +*** goal2 = [111 .. oo] :: [Integer] *** goal3 = [-oo .. oo] :: [Integer] *** goal4 = [-oo .. oo] :: [Integer] *** goal5 = [-oo .. oo] :: [Integer] diff --git a/SBVTestSuite/GoldFiles/qUninterp1.gold b/SBVTestSuite/GoldFiles/qUninterp1.gold --- a/SBVTestSuite/GoldFiles/qUninterp1.gold +++ b/SBVTestSuite/GoldFiles/qUninterp1.gold @@ -30,9 +30,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 @@ -72,7 +72,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 "5.1.0") +[RECV] (:version "5.3.2 - build hashcode b411c90217766c924e6ea3d0b51f452a89fd8fc2") [SEND] (get-info :status) [RECV] (:status sat) [GOOD] (define-fun s16 () Int 4) @@ -103,7 +103,7 @@ [SEND] (get-info :reason-unknown) [RECV] (:reason-unknown "unknown") [SEND] (get-info :version) -[RECV] (:version "5.1.0") +[RECV] (:version "5.3.2 - build hashcode b411c90217766c924e6ea3d0b51f452a89fd8fc2") [SEND] (get-info :memory) [RECV] unsupported [SEND] (get-info :time) @@ -164,19 +164,20 @@ [SEND] (get-proof) [RECV] ((set-logic ALL) (proof - (let (($x268 (<= s0 6))) - (let (($x269 (not $x268))) - (let (($x276 (or (not bey) $x269))) - (let ((@x274 (monotonicity (rewrite (= (> s0 6) $x269)) (= (=> bey (> s0 6)) (=> bey $x269))))) - (let ((@x280 (trans @x274 (rewrite (= (=> bey $x269) $x276)) (= (=> bey (> s0 6)) $x276)))) - (let ((@x281 (mp (asserted (=> bey (> s0 6))) @x280 $x276))) - (let (($x293 (>= s0 6))) - (let (($x292 (not $x293))) - (let (($x300 (or (not hey) $x292))) - (let ((@x291 (trans (rewrite (= (< s0 6) (not (<= 6 s0)))) (rewrite (= (not (<= 6 s0)) $x292)) (= (< s0 6) $x292)))) - (let ((@x304 (trans (monotonicity @x291 (= (=> hey (< s0 6)) (=> hey $x292))) (rewrite (= (=> hey $x292) $x300)) (= (=> hey (< s0 6)) $x300)))) - (let ((@x305 (mp (asserted (=> hey (< s0 6))) @x304 $x300))) - (unit-resolution ((_ th-lemma arith farkas 1 1) (or $x293 $x268)) (unit-resolution @x305 (asserted hey) $x292) (unit-resolution @x281 (asserted bey) $x269) false))))))))))))))) + (let (($x271 (<= s0 6))) + (let (($x283 (not $x271))) + (let (($x289 (or (not bey) $x283))) + (let ((@x270 (monotonicity (rewrite (= (> s0 6) $x283)) (= (=> bey (> s0 6)) (=> bey $x283))))) + (let ((@x279 (trans @x270 (rewrite (= (=> bey $x283) $x289)) (= (=> bey (> s0 6)) $x289)))) + (let ((@x281 (mp (asserted (=> bey (> s0 6))) @x279 $x289))) + (let (($x287 (>= s0 6))) + (let (($x276 (not $x287))) + (let (($x305 (or (not hey) $x276))) + (let ((@x297 (monotonicity (rewrite (= (<= 6 s0) $x287)) (= (not (<= 6 s0)) $x276)))) + (let ((@x300 (trans (rewrite (= (< s0 6) (not (<= 6 s0)))) @x297 (= (< s0 6) $x276)))) + (let ((@x309 (trans (monotonicity @x300 (= (=> hey (< s0 6)) (=> hey $x276))) (rewrite (= (=> hey $x276) $x305)) (= (=> hey (< s0 6)) $x305)))) + (let ((@x310 (mp (asserted (=> hey (< s0 6))) @x309 $x305))) + (unit-resolution ((_ th-lemma arith farkas 1 1) (or $x271 $x287)) (unit-resolution @x310 (asserted hey) $x276) (unit-resolution @x281 (asserted bey) $x283) false)))))))))))))))) [SEND, TimeOut: 90000ms] (get-assertions) [RECV] ((! s7 :named |a > 0|) diff --git a/SBVTestSuite/GoldFiles/query_Interpolant3.gold b/SBVTestSuite/GoldFiles/query_Interpolant3.gold --- a/SBVTestSuite/GoldFiles/query_Interpolant3.gold +++ b/SBVTestSuite/GoldFiles/query_Interpolant3.gold @@ -29,9 +29,9 @@ [GOOD] (define-fun s9 () Bool (not s8)) [GOOD] (define-fun s10 () Bool (and s7 s9)) [SEND] (get-interpolant s6 s10) -[RECV] (= s2 s1) +[RECV] (= s1 s2) *** Solver : Z3 *** Exit code: ExitSuccess FINAL OUTPUT: -"(= s2 s1)" +"(= s1 s2)" diff --git a/SBVTestSuite/GoldFiles/query_Interpolant4.gold b/SBVTestSuite/GoldFiles/query_Interpolant4.gold --- a/SBVTestSuite/GoldFiles/query_Interpolant4.gold +++ b/SBVTestSuite/GoldFiles/query_Interpolant4.gold @@ -34,7 +34,7 @@ [GOOD] (define-fun s12 () Bool (distinct s10 s11)) [GOOD] (define-fun s13 () Bool (and s9 s12)) [SEND] (get-interpolant s8 s13) -[RECV] (or (and (= s1 s2) (= s1 s3)) +[RECV] (or (and (= s1 s2) (= s0 s3)) (<= (+ (* (- 1) s1) s0) (- 1)) (<= (+ (* (- 1) s0) s1) (- 1)) (= s2 s3)) @@ -42,4 +42,4 @@ *** Exit code: ExitSuccess FINAL OUTPUT: -"(or (and (= s1 s2) (= s1 s3)) (<= (+ (* (- 1) s1) s0) (- 1)) (<= (+ (* (- 1) s0) s1) (- 1)) (= s2 s3))" +"(or (and (= s1 s2) (= s0 s3)) (<= (+ (* (- 1) s1) s0) (- 1)) (<= (+ (* (- 1) s0) s1) (- 1)) (= s2 s3))" diff --git a/SBVTestSuite/GoldFiles/query_uiSat_test1.gold b/SBVTestSuite/GoldFiles/query_uiSat_test1.gold --- a/SBVTestSuite/GoldFiles/query_uiSat_test1.gold +++ b/SBVTestSuite/GoldFiles/query_uiSat_test1.gold @@ -31,6 +31,6 @@ [SEND] (get-value (q1)) [RECV] ((q1 (lambda ((x!1 Bool)) x!1))) -MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [], modelUIFuns = [("q1",(True,SBool -> SBool,Right ([([True :: Bool],True :: Bool)],False :: Bool)))]} +MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [], modelUIFuns = [("q1",(True,SBool -> SBool,Right ([([True :: Bool],True :: Bool)],False :: Bool)))], modelUIBindings = Nothing} DONE.*** Solver : Z3 *** Exit code: ExitSuccess diff --git a/SBVTestSuite/GoldFiles/query_uiSat_test2.gold b/SBVTestSuite/GoldFiles/query_uiSat_test2.gold --- a/SBVTestSuite/GoldFiles/query_uiSat_test2.gold +++ b/SBVTestSuite/GoldFiles/query_uiSat_test2.gold @@ -36,6 +36,6 @@ false true))) -MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [], modelUIFuns = [("q2",(True,SBool -> SBool -> SBool,Right ([([True :: Bool,False :: Bool],True :: Bool),([True :: Bool,True :: Bool],True :: Bool)],False :: Bool)))]} +MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [], modelUIFuns = [("q2",(True,SBool -> SBool -> SBool,Right ([([True :: Bool,False :: Bool],True :: Bool),([True :: Bool,True :: Bool],True :: Bool)],False :: Bool)))], modelUIBindings = Nothing} DONE.*** Solver : Z3 *** Exit code: ExitSuccess 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 @@ -152,7 +152,7 @@ (seq.unit (_ +zero 8 24))) 210))) [SEND] (get-value (q6)) -[RECV] ((q6 (_ as-array q6))) +[RECV] ((q6 ((as const (Array Int Bool)) false))) *** Solver : Z3 *** Exit code: ExitSuccess diff --git a/SBVTestSuite/GoldFiles/recursive1_ack.gold b/SBVTestSuite/GoldFiles/recursive1_ack.gold --- a/SBVTestSuite/GoldFiles/recursive1_ack.gold +++ b/SBVTestSuite/GoldFiles/recursive1_ack.gold @@ -468,32 +468,32 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (s15)) -[RECV] ((s15 2)) +[RECV] ((s15 0)) [SEND] (get-value (s17)) [RECV] ((s17 1)) [SEND] (get-value (s19)) -[RECV] ((s19 1)) +[RECV] ((s19 0)) [SEND] (get-value (s21)) -[RECV] ((s21 2)) +[RECV] ((s21 0)) [SEND] (get-value (s0)) [RECV] ((s0 1)) [SEND] (get-value (s1)) -[RECV] ((s1 2)) +[RECV] ((s1 (- 1))) [SEND] (get-value (s8)) [RECV] ((s8 0)) [SEND] (get-value (s10)) -[RECV] ((s10 2)) +[RECV] ((s10 (- 1))) [SEND] (get-value (s11)) [RECV] ((s11 0)) *** Solver : Z3 *** Exit code: ExitSuccess [MEASURE] ack @(SBV Integer -> SBV Integer -> SBV Integer): smax 0 arg2 failed strict decrease: Falsifiable. Counter-example: - arg0 = 1 :: Integer - arg1 = 2 :: Integer - before = 2 :: Integer - then[1] = 1 :: Integer - then[2] = 1 :: Integer - then[3] = 2 :: Integer + arg0 = 1 :: Integer + arg1 = -1 :: Integer + before = 0 :: Integer + then[1] = 1 :: Integer + then[2] = 0 :: Integer + then[3] = 0 :: Integer [MEASURE] ack @(SBV Integer -> SBV Integer -> SBV Integer): trying next candidate.. [MEASURE] ack @(SBV Integer -> SBV Integer -> SBV Integer): trying abs arg1 + smax 0 arg1 + abs arg2 + smax 0 arg2 [MEASURE] replayDAG {ack @(SBV Integer -> SBV Integer -> SBV Integer)}: replaying 10 node(s) diff --git a/SBVTestSuite/GoldFiles/recursive6_uselessContract.gold b/SBVTestSuite/GoldFiles/recursive6_uselessContract.gold --- a/SBVTestSuite/GoldFiles/recursive6_uselessContract.gold +++ b/SBVTestSuite/GoldFiles/recursive6_uselessContract.gold @@ -112,21 +112,21 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (s28)) -[RECV] ((s28 12)) +[RECV] ((s28 101)) [SEND] (get-value (s31)) -[RECV] ((s31 1)) +[RECV] ((s31 90)) [SEND] (get-value (s34)) -[RECV] ((s34 12)) +[RECV] ((s34 101)) [SEND] (get-value (s0)) -[RECV] ((s0 89)) +[RECV] ((s0 0)) [SEND] (get-value (s7)) -[RECV] ((s7 89)) +[RECV] ((s7 0)) [SEND] (get-value (s8)) [RECV] ((s8 0)) [SEND] (get-value (s13)) [RECV] ((s13 0)) [SEND] (get-value (s14)) -[RECV] ((s14 89)) +[RECV] ((s14 0)) [SEND] (get-value (s20)) [RECV] ((s20 0)) [SEND] (get-value (s21)) @@ -141,10 +141,10 @@ *** Function: mc91triv :: SBV Integer -> SBV Integer *** *** Falsifiable. Counter-example: -*** arg = 89 :: Integer -*** before = 12 :: Integer -*** then[1] = 1 :: Integer -*** then[2] = 12 :: Integer +*** arg = 0 :: Integer +*** before = 101 :: Integer +*** then[1] = 90 :: Integer +*** then[2] = 101 :: Integer *** *** The measure must strictly decrease at every recursive call, *** and the contract must hold for the function's output. 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 @@ -60,45 +60,45 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (s0)) -[RECV] ((s0 (store (store ((as const (Array E Bool)) false) A true) B true))) +[RECV] ((s0 (store ((as const (Array E Bool)) true) C false))) [GOOD] (push 1) -[GOOD] (define-fun s7 () (Array E Bool) (store (store ((as const (Array E Bool)) false) (as B E) true) (as A E) true)) +[GOOD] (define-fun s7 () (Array E Bool) (store ((as const (Array E Bool)) true) (as C E) false)) [GOOD] (define-fun s8 () Bool (distinct s0 s7)) [GOOD] (assert s8) Fast allSat, Looking for solution 5 [SEND] (check-sat) [RECV] sat [SEND] (get-value (s0)) -[RECV] ((s0 (store ((as const (Array E Bool)) false) B true))) +[RECV] ((s0 (store (store ((as const (Array E Bool)) true) C false) A false))) [GOOD] (push 1) -[GOOD] (define-fun s9 () (Array E Bool) (store ((as const (Array E Bool)) false) (as B E) true)) +[GOOD] (define-fun s9 () (Array E Bool) (store (store ((as const (Array E Bool)) true) (as C E) false) (as A E) false)) [GOOD] (define-fun s10 () Bool (distinct s0 s9)) [GOOD] (assert s10) Fast allSat, Looking for solution 6 [SEND] (check-sat) [RECV] sat [SEND] (get-value (s0)) -[RECV] ((s0 (store ((as const (Array E Bool)) true) A false))) +[RECV] ((s0 (store (store ((as const (Array E Bool)) false) C true) B true))) [GOOD] (push 1) -[GOOD] (define-fun s11 () (Array E Bool) (store ((as const (Array E Bool)) true) (as A E) false)) +[GOOD] (define-fun s11 () (Array E Bool) (store (store ((as const (Array E Bool)) false) (as C E) true) (as B E) true)) [GOOD] (define-fun s12 () Bool (distinct s0 s11)) [GOOD] (assert s12) Fast allSat, Looking for solution 7 [SEND] (check-sat) [RECV] sat [SEND] (get-value (s0)) -[RECV] ((s0 (store (store ((as const (Array E Bool)) false) C true) A true))) +[RECV] ((s0 (store ((as const (Array E Bool)) true) B false))) [GOOD] (push 1) -[GOOD] (define-fun s13 () (Array E Bool) (store (store ((as const (Array E Bool)) false) (as C E) true) (as A E) true)) +[GOOD] (define-fun s13 () (Array E Bool) (store ((as const (Array E Bool)) true) (as B E) false)) [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 (store ((as const (Array E Bool)) false) C true) A true) B true))) +[RECV] ((s0 ((as const (Array E Bool)) true))) [GOOD] (push 1) -[GOOD] (define-fun s15 () (Array E Bool) (store (store (store ((as const (Array E Bool)) false) (as C E) true) (as B E) true) (as A E) true)) +[GOOD] (define-fun s15 () (Array E Bool) ((as const (Array E Bool)) true)) [GOOD] (define-fun s16 () Bool (distinct s0 s15)) [GOOD] (assert s16) Fast allSat, Looking for solution 9 @@ -117,15 +117,15 @@ FINAL: Solution #1: - s0 = {A,B,C} :: {E} + s0 = U :: {E} Solution #2: - s0 = {A,C} :: {E} + s0 = U - {B} :: {E} Solution #3: - s0 = U - {A} :: {E} + s0 = {B,C} :: {E} Solution #4: - s0 = {B} :: {E} + s0 = U - {A,C} :: {E} Solution #5: - s0 = {A,B} :: {E} + s0 = U - {C} :: {E} Solution #6: s0 = {A} :: {E} Solution #7: diff --git a/SBVTestSuite/GoldFiles/sumBimapPlus.gold b/SBVTestSuite/GoldFiles/sumBimapPlus.gold --- a/SBVTestSuite/GoldFiles/sumBimapPlus.gold +++ b/SBVTestSuite/GoldFiles/sumBimapPlus.gold @@ -49,6 +49,6 @@ [SEND] (get-value (s0)) [RECV] ((s0 (Left (- 1)))) -MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [("x",Left (-1) :: Either Integer Integer)], modelUIFuns = []} +MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [("x",Left (-1) :: Either Integer Integer)], modelUIFuns = [], modelUIBindings = Nothing} DONE.*** Solver : Z3 *** Exit code: ExitSuccess diff --git a/SBVTestSuite/GoldFiles/sumEitherSat.gold b/SBVTestSuite/GoldFiles/sumEitherSat.gold --- a/SBVTestSuite/GoldFiles/sumEitherSat.gold +++ b/SBVTestSuite/GoldFiles/sumEitherSat.gold @@ -40,6 +40,6 @@ [SEND] (get-value (s0)) [RECV] ((s0 (Right false))) -MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [("x",Right False :: Either Integer Bool)], modelUIFuns = []} +MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [("x",Right False :: Either Integer Bool)], modelUIFuns = [], modelUIBindings = Nothing} DONE.*** Solver : Z3 *** Exit code: ExitSuccess diff --git a/SBVTestSuite/GoldFiles/sumLiftEither.gold b/SBVTestSuite/GoldFiles/sumLiftEither.gold --- a/SBVTestSuite/GoldFiles/sumLiftEither.gold +++ b/SBVTestSuite/GoldFiles/sumLiftEither.gold @@ -42,6 +42,6 @@ [SEND] (get-value (s1)) [RECV] ((s1 "A")) -MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [("i",0 :: Integer),("c",'A' :: Char)], modelUIFuns = []} +MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [("i",0 :: Integer),("c",'A' :: Char)], modelUIFuns = [], modelUIBindings = Nothing} DONE.*** Solver : Z3 *** Exit code: ExitSuccess diff --git a/SBVTestSuite/GoldFiles/sumLiftMaybe.gold b/SBVTestSuite/GoldFiles/sumLiftMaybe.gold --- a/SBVTestSuite/GoldFiles/sumLiftMaybe.gold +++ b/SBVTestSuite/GoldFiles/sumLiftMaybe.gold @@ -36,6 +36,6 @@ [SEND] (get-value (s0)) [RECV] ((s0 0)) -MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [("i",0 :: Integer)], modelUIFuns = []} +MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [("i",0 :: Integer)], modelUIFuns = [], modelUIBindings = Nothing} DONE.*** Solver : Z3 *** Exit code: ExitSuccess diff --git a/SBVTestSuite/GoldFiles/sumMaybe.gold b/SBVTestSuite/GoldFiles/sumMaybe.gold --- a/SBVTestSuite/GoldFiles/sumMaybe.gold +++ b/SBVTestSuite/GoldFiles/sumMaybe.gold @@ -53,6 +53,6 @@ [SEND] (get-value (s0)) [RECV] ((s0 (Just 0))) -MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [("x",Just 0 :: Maybe Integer)], modelUIFuns = []} +MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [("x",Just 0 :: Maybe Integer)], modelUIFuns = [], modelUIBindings = Nothing} DONE.*** Solver : Z3 *** Exit code: ExitSuccess diff --git a/SBVTestSuite/GoldFiles/sumMaybeBoth.gold b/SBVTestSuite/GoldFiles/sumMaybeBoth.gold --- a/SBVTestSuite/GoldFiles/sumMaybeBoth.gold +++ b/SBVTestSuite/GoldFiles/sumMaybeBoth.gold @@ -44,6 +44,6 @@ [SEND] (get-value (s1)) [RECV] ((s1 (Just 3))) -MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [("s0",Left 2 :: Either Integer Integer),("s1",Just 3 :: Maybe Integer)], modelUIFuns = []} +MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [("s0",Left 2 :: Either Integer Integer),("s1",Just 3 :: Maybe Integer)], modelUIFuns = [], modelUIBindings = Nothing} DONE.*** Solver : Z3 *** Exit code: ExitSuccess diff --git a/SBVTestSuite/GoldFiles/sumMergeEither1.gold b/SBVTestSuite/GoldFiles/sumMergeEither1.gold --- a/SBVTestSuite/GoldFiles/sumMergeEither1.gold +++ b/SBVTestSuite/GoldFiles/sumMergeEither1.gold @@ -41,6 +41,6 @@ [SEND] (get-value (s2)) [RECV] ((s2 false)) -MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [("s0",Left 2 :: Either Integer Bool),("s1",Left 2 :: Either Integer Bool),("s2",False :: Bool)], modelUIFuns = []} +MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [("s0",Left 2 :: Either Integer Bool),("s1",Left 2 :: Either Integer Bool),("s2",False :: Bool)], modelUIFuns = [], modelUIBindings = Nothing} DONE.*** Solver : Z3 *** Exit code: ExitSuccess diff --git a/SBVTestSuite/GoldFiles/sumMergeEither2.gold b/SBVTestSuite/GoldFiles/sumMergeEither2.gold --- a/SBVTestSuite/GoldFiles/sumMergeEither2.gold +++ b/SBVTestSuite/GoldFiles/sumMergeEither2.gold @@ -41,6 +41,6 @@ [SEND] (get-value (s2)) [RECV] ((s2 false)) -MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [("s0",Right False :: Either Integer Bool),("s1",Right False :: Either Integer Bool),("s2",False :: Bool)], modelUIFuns = []} +MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [("s0",Right False :: Either Integer Bool),("s1",Right False :: Either Integer Bool),("s2",False :: Bool)], modelUIFuns = [], modelUIBindings = Nothing} DONE.*** Solver : Z3 *** Exit code: ExitSuccess diff --git a/SBVTestSuite/GoldFiles/sumMergeMaybe1.gold b/SBVTestSuite/GoldFiles/sumMergeMaybe1.gold --- a/SBVTestSuite/GoldFiles/sumMergeMaybe1.gold +++ b/SBVTestSuite/GoldFiles/sumMergeMaybe1.gold @@ -41,6 +41,6 @@ [SEND] (get-value (s2)) [RECV] ((s2 false)) -MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [("s0",Nothing :: Maybe Integer),("s1",Nothing :: Maybe Integer),("s2",False :: Bool)], modelUIFuns = []} +MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [("s0",Nothing :: Maybe Integer),("s1",Nothing :: Maybe Integer),("s2",False :: Bool)], modelUIFuns = [], modelUIBindings = Nothing} DONE.*** Solver : Z3 *** Exit code: ExitSuccess diff --git a/SBVTestSuite/GoldFiles/sumMergeMaybe2.gold b/SBVTestSuite/GoldFiles/sumMergeMaybe2.gold --- a/SBVTestSuite/GoldFiles/sumMergeMaybe2.gold +++ b/SBVTestSuite/GoldFiles/sumMergeMaybe2.gold @@ -41,6 +41,6 @@ [SEND] (get-value (s2)) [RECV] ((s2 false)) -MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [("s0",Just 2 :: Maybe Integer),("s1",Just 2 :: Maybe Integer),("s2",False :: Bool)], modelUIFuns = []} +MODEL: SMTModel {modelObjectives = [], modelBindings = Nothing, modelAssocs = [("s0",Just 2 :: Maybe Integer),("s1",Just 2 :: Maybe Integer),("s2",False :: Bool)], modelUIFuns = [], modelUIBindings = Nothing} DONE.*** 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 @@ -28,7 +28,7 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q1)) -[RECV] ((q1 (_ as-array q1))) +[RECV] ((q1 ((as const (Array Bool Bool)) false))) [GOOD] (define-fun q1_model1 ((x!0 Bool)) Bool false ) 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 @@ -29,7 +29,7 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q2)) -[RECV] ((q2 (_ as-array q2))) +[RECV] ((q2 ((as const (Array Bool Bool Bool)) false))) [GOOD] (define-fun q2_model1 ((x!0 Bool) (x!1 Bool)) Bool false ) 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 @@ -32,9 +32,9 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q1)) -[RECV] ((q1 (_ as-array q1))) +[RECV] ((q1 ((as const (Array Bool Bool)) false))) [SEND] (get-value (q2)) -[RECV] ((q2 (_ as-array q2))) +[RECV] ((q2 ((as const (Array Bool Bool Bool)) false))) [GOOD] (define-fun q1_model1 ((x!0 Bool)) Bool false ) @@ -60,7 +60,7 @@ [SEND] (get-value (q1)) [RECV] ((q1 ((as const (Array Bool Bool)) true))) [SEND] (get-value (q2)) -[RECV] ((q2 (_ as-array q2))) +[RECV] ((q2 ((as const (Array Bool Bool Bool)) false))) [GOOD] (define-fun q1_model2 ((x!0 Bool)) Bool true ) diff --git a/SBVTestSuite/GoldFiles/validate_1.gold b/SBVTestSuite/GoldFiles/validate_1.gold --- a/SBVTestSuite/GoldFiles/validate_1.gold +++ b/SBVTestSuite/GoldFiles/validate_1.gold @@ -32,20 +32,8 @@ [VALIDATE] x = -0.0 :: Float [VALIDATE] There are no constraints to check. [VALIDATE] Validating outputs. +[VALIDATE] All outputs are satisfied. Validation complete. FINAL OUTPUT: -*** Data.SBV: Cannot validate the model, since s4 is not concretely computable. -*** -*** Assignment: -*** -*** x = -0.0 :: Float -*** -*** Not all floating point operations are supported concretely. -*** -*** SBV's model validator is incomplete, and cannot handle this particular case. -*** Please report this as a feature request or possibly a bug! -*** -*** Alleged model: -*** -*** Satisfiable. Model: -*** x = -0.0 :: Float +Satisfiable. Model: + x = -0.0 :: Float diff --git a/SBVTestSuite/GoldFiles/validate_2.gold b/SBVTestSuite/GoldFiles/validate_2.gold --- a/SBVTestSuite/GoldFiles/validate_2.gold +++ b/SBVTestSuite/GoldFiles/validate_2.gold @@ -25,27 +25,15 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (s0)) -[RECV] ((s0 (fp #b0 #x00 #b00000000101010111000111))) +[RECV] ((s0 (fp #b0 #x00 #b11111111111111010101000))) *** Solver : Z3 *** Exit code: ExitSuccess [VALIDATE] Validating the model. Assignment: -[VALIDATE] x = 3.0771e-41 :: Float +[VALIDATE] x = 1.1754461e-38 :: Float [VALIDATE] There are no constraints to check. [VALIDATE] Validating outputs. +[VALIDATE] All outputs are satisfied. Validation complete. FINAL OUTPUT: -*** Data.SBV: Cannot validate the model, since s4 is not concretely computable. -*** -*** Assignment: -*** -*** x = 3.0771e-41 :: Float -*** -*** Floating point FMA operation is not supported concretely. -*** -*** SBV's model validator is incomplete, and cannot handle this particular case. -*** Please report this as a feature request or possibly a bug! -*** -*** Alleged model: -*** -*** Satisfiable. Model: -*** x = 3.0771e-41 :: Float +Satisfiable. Model: + x = 1.1754461e-38 :: Float diff --git a/SBVTestSuite/SBVTest.hs b/SBVTestSuite/SBVTest.hs --- a/SBVTestSuite/SBVTest.hs +++ b/SBVTestSuite/SBVTest.hs @@ -109,6 +109,7 @@ import qualified TestSuite.Puzzles.MagicSquare import qualified TestSuite.Puzzles.NQueens import qualified TestSuite.Puzzles.PowerSet +import qualified TestSuite.Puzzles.Rubik import qualified TestSuite.Puzzles.Sudoku import qualified TestSuite.Puzzles.Temperature import qualified TestSuite.Puzzles.U2Bridge @@ -245,6 +246,7 @@ , TestSuite.Puzzles.MagicSquare.tests , TestSuite.Puzzles.NQueens.tests , TestSuite.Puzzles.PowerSet.tests + , TestSuite.Puzzles.Rubik.tests , TestSuite.Puzzles.Sudoku.tests , TestSuite.Puzzles.Temperature.tests , TestSuite.Puzzles.U2Bridge.tests diff --git a/SBVTestSuite/TestSuite/ADT/ADT.hs b/SBVTestSuite/TestSuite/ADT/ADT.hs --- a/SBVTestSuite/TestSuite/ADT/ADT.hs +++ b/SBVTestSuite/TestSuite/ADT/ADT.hs @@ -56,10 +56,8 @@ | KChar Char | KRational Rational | KArray (ArrayModel Integer Bool) - -- NB. KADT is covered by the APair constructor above. KSet is deliberately - -- absent: t05 has to run on cvc5 (z3 is buggy on it), and cvc5 doesn't - -- support sets; a single set field here would make every test over this - -- type require set support. Sets in ADT fields are covered by t08 instead. + -- NB. KADT is covered by the APair constructor above. Sets in ADT fields + -- are covered by t08. deriving Show mkSymbolic [''ADT] @@ -120,9 +118,8 @@ constrain $ getAInteger_1 a .>= 0 constrain $ getAInteger_1 a .<= 5 --- z3 is buggy on this. So we use cvc5. See: https://github.com/Z3Prover/z3/issues/7842 t05 :: FilePath -> IO () -t05 rf = do AllSatResult _ _ _ ms <- allSatWith cvc5{verbose=True, redirectVerbose = Just rf, allSatMaxModelCount=Just 10} t +t05 rf = do AllSatResult _ _ _ ms <- allSatWith z3{verbose=True, redirectVerbose = Just rf, allSatMaxModelCount=Just 10} t let sh m = appendFile rf $ "\nMODEL:" ++ show (SatResult m) mapM_ sh ms where t = do a :: SADT <- free "a" 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 @@ -83,7 +83,7 @@ .== write (empty 1) [(i, i) | i <- [0 .. (3 :: WordN 2)]]) :: Symbolic SBool , testCase "array_misc_6" $ (write (empty 0) [(i, i) | i <- [0 .. (3 :: WordN 2)]] - .== write (empty 1) [(i, i) | i <- [0 .. (3 :: WordN 2)]]) `showsAs` " :: SBool" + .== write (empty 1) [(i, i) | i <- [0 .. (3 :: WordN 2)]]) `showsAs` "True" , goldenCapturedIO "array_misc_7" $ t proveWith $ write (empty 0) [(i, i) | i <- [0 .. (3 :: WordN 2)]] .== write (empty 0) [(i, i) | i <- [0 .. (3 :: WordN 2)]] diff --git a/SBVTestSuite/TestSuite/Basics/ModelValidate.hs b/SBVTestSuite/TestSuite/Basics/ModelValidate.hs --- a/SBVTestSuite/TestSuite/Basics/ModelValidate.hs +++ b/SBVTestSuite/TestSuite/Basics/ModelValidate.hs @@ -9,17 +9,50 @@ -- Few validate tests ----------------------------------------------------------------------------- +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleContexts #-} +{-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE TemplateHaskell #-} +{-# LANGUAGE TypeApplications #-} {-# OPTIONS_GHC -Wall -Werror #-} module TestSuite.Basics.ModelValidate (testsABC, tests) where import qualified Control.Exception as C -import Data.List (isPrefixOf) +import Data.List (isPrefixOf, isInfixOf) +import qualified Data.Set as Set + +import qualified Data.SBV.List as L +import qualified Data.SBV.Maybe as M +import qualified Data.SBV.Set as S + +import Data.SBV.Tools.Overflow + +import qualified Data.SBV.Internals as I + +import Test.Tasty.HUnit (assertBool) + import Utils.SBVTestFramework +data T = Leaf | Node T Integer T deriving Show +mkSymbolic [''T] + +data U +mkSymbolic [''U] + +data E = A | B | C deriving (Show, Eq, Ord) +mkSymbolic [''E] + +-- Nested recursive call, used to make sure termination checks don't trip validation +ack :: SInteger -> SInteger -> SInteger +ack = smtFunction "ack" $ \m n -> ite (m .<= 0) (n + 1) (ite (n .<= 0) (ack (m - 1) 1) (ack (m - 1) (ack m (n - 1)))) + +cnt :: SInteger -> SInteger +cnt = smtFunction "cnt" $ \n -> ite (n .<= 0) 0 (1 + cnt (n - 1)) + -- Test suite, this needs ABC testsABC :: TestTree testsABC = testGroup "Basics.ModelValidate.ABC" [ @@ -29,7 +62,7 @@ appendFile goldFile ("\nFINAL OUTPUT:\n" ++ show r ++ "\n") tests :: TestTree -tests = testGroup "Basics.ModelValidate" [ +tests = testGroup "Basics.ModelValidate" $ [ goldenCapturedIO "validate_1" $ t satWith t1 , goldenCapturedIO "validate_2" $ t satWith t2 , goldenCapturedIO "validate_3" $ t satWith t3 @@ -37,7 +70,20 @@ , goldenCapturedIO "validate_5" $ t satWith t4 , goldenCapturedIO "validate_6" $ t proveWith t4 , goldenCapturedIO "validate_7" $ tE satWith t5 + , testCase "validate_8" t6 ] + ++ [testCase ("validate_ok_" ++ n) (validates p) | (n, p) <- okSat] + ++ [testCase ("validate_cex_" ++ n) (validatesP p) | (n, p) <- okCex] + ++ [testCase ("validate_cant_" ++ n) (cantValidate msg p) | (n, msg, p) <- cant] + ++ [ testCase "validate_allSat_ui" $ validatesAll $ \(x :: SInteger) -> (uninterpret "g" :: SInteger -> SInteger) x .== 3 .&& x .>= 0 + , testCase "validate_nonModelVar_ui" $ do + r <- satWith z3{validateModel = True, isNonModelVar = (== "q")} $ \(x :: SInteger) -> (uninterpret "q" :: SInteger -> SInteger) x .== 3 + checkSat (show r) r + ] + ++ [testCase ("validate_fp_concrete_" ++ n) a | (n, a) <- fpConcrete] + ++ [testCase ("validate_ovf_concrete_" ++ n) a | (n, a) <- ovfConcrete] + ++ [testCase ("validate_set_concrete_" ++ n) a | (n, a) <- setConcrete] + ++ [testCase ("validate_arr_concrete_" ++ n) a | (n, a) <- arrConcrete] where t f test goldFile = do r <- f defaultSMTCfg{verbose=True, redirectVerbose = Just goldFile, validateModel = True} test appendFile goldFile ("\nFINAL OUTPUT:\n" ++ show r ++ "\n") @@ -65,3 +111,281 @@ t5 :: Predicate t5 = do x <- free "x" pure $ quantifiedBool $ \(Forall y) -> fpIsPoint y .=> x .<= (y::SFloat) + + -- Overflow checks with the given operation, regardless of the signedness of the arguments. The public + -- API always picks the signedness matching the arguments, so we build these directly. + ovf1 :: I.OvOp -> SBV a -> SBool + ovf1 o x = ovf o [I.unSBV x] + + ovf2 :: I.OvOp -> SBV a -> SBV a -> SBool + ovf2 o x y = ovf o [I.unSBV x, I.unSBV y] + + ovf :: I.OvOp -> [I.SVal] -> SBool + ovf o args = I.SBV $ I.SVal I.KBool $ Right $ I.cache r + where r st = do svs <- mapM (I.svToSV st) args + I.newExpr st I.KBool (I.SBVApp (I.OverflowOp o) svs) + + -- Problems whose models should validate + okSat :: [(String, Predicate)] + okSat = [ ("usort_neq", do u <- free "u"; v <- free "v"; pure $ (u :: SU) ./= v) + , ("ack", do m <- free "m"; n <- free "n"; pure $ m .== 1 .&& n .== 2 .&& ack m n .== 4) + , ("ui_const", do x <- sInteger "x"; pure $ x .== uninterpret "c" + 1) + , ("ui_fun", do x <- sInteger "x"; pure $ (uninterpret "f" :: SInteger -> SInteger) x .== 3) + , ("ui_fun2", do x <- sInteger "x"; y <- sInteger "y"; pure $ (uninterpret "k" :: SInteger -> SInteger -> SInteger) x y .== x + y + 1 .&& x .> y) + , ("ui_uncurried", do x <- sInteger "x"; y <- sInteger "y"; pure $ (uninterpret "ku" :: (SInteger, SInteger) -> SInteger) (x, y) .== 7) + , ("ui_bool", do x <- sInteger "x"; let p = uninterpret "p" :: SInteger -> SBool in pure $ p x .&& sNot (p (x + 1))) + , ("ui_adt_arg", do e <- free "e"; pure $ (uninterpret "g" :: ST -> SInteger) e .== 3 .&& isNode e) + , ("ui_adt_res", do x <- sInteger "x"; pure $ isNode ((uninterpret "h" :: SInteger -> ST) x) .&& x .> 2) + , ("ui_usort_arg", do u <- free "u"; pure $ (uninterpret "us" :: SU -> SInteger) u .== 2) + , ("ui_array", do i <- sInteger "i"; pure $ readArray (uninterpret "arr" :: SArray Integer Integer) i .== 5) + , ("ui_float_rtz", pure $ fpAdd sRoundTowardZero (uninterpret "cf" :: SFloat) 1 .== 3) + , ("float_add_rtz", do x <- sFloat "x"; pure $ fpAdd sRoundTowardZero x 1 .== 3) + , ("float_mul_rtp", do x <- sFloat "x"; y <- sFloat "y"; pure $ fpMul sRoundTowardPositive x y .== 3.5 .&& x .> 1 .&& y .> 1) + , ("float_fma", do x <- sFloat "x"; pure $ fpFMA sRNE x x x .== 12) + , ("double_fma_rtn", do x <- sDouble "x"; pure $ fpFMA sRoundTowardNegative x x 1 .== 5) + , ("fp512_rtz", do x <- sFloatingPoint "x"; pure $ fpAdd sRoundTowardZero x 1 .== (3 :: SFloatingPoint 5 12)) + , ("ovf_add", do x <- sWord8 "x"; y <- sWord8 "y"; pure $ bvAddO x y) + , ("ovf_mul_signed", do x <- sInt8 "x"; y <- sInt8 "y"; pure $ bvMulO x y .&& x .> 3) + , ("ovf_div_signed", do x <- sInt8 "x"; y <- sInt8 "y"; pure $ bvDivO x y) + , ("ovf_neg_signed", do x <- sInt8 "x"; pure $ bvNegO x) + -- Overflow checks whose signedness differs from their arguments. The models are only valid if we + -- interpret the arguments as SMTLib does: Signed or unsigned as determined by the operation. + , ("ovf_signed_add_on_unsigned", do x <- sWord8 "x"; y <- sWord8 "y"; pure $ ovf2 (I.PlusOv True) x y .&& sNot (ovf2 (I.PlusOv False) x y)) + , ("ovf_unsigned_add_on_signed", do x <- sInt8 "x"; y <- sInt8 "y"; pure $ ovf2 (I.PlusOv False) x y .&& sNot (ovf2 (I.PlusOv True) x y)) + , ("ovf_signed_mul_on_unsigned", do x <- sWord8 "x"; y <- sWord8 "y"; pure $ ovf2 (I.MulOv True) x y .&& sNot (ovf2 (I.MulOv False) x y)) + , ("ovf_div_on_unsigned", do x <- sWord8 "x"; y <- sWord8 "y"; pure $ ovf2 I.DivOv x y) + , ("ovf_neg_on_unsigned", do x <- sWord8 "x"; pure $ ovf1 I.NegOv x) + , ("set_member_union",do s <- free "s"; pure $ 3 `S.member` ((s :: SSet Integer) `S.union` S.singleton 5)) + -- Bit-wise and/or must not be short-cut like their boolean counterparts + , ("ui_bitwise_or", let x = uninterpret "bw1" :: SWord8 in pure $ x .== 2 .&& (x .|. 4) .== 6) + , ("ui_bitwise_and", let x = uninterpret "bw2" :: SWord8 in pure $ x .== 0 .&& (x .&. 5) .== 0) + -- No-op writes change the representation of an array, but not its value + , ("ui_fun_array_noop_write", do + a <- free "a"; b <- free "b"; c <- free "c" + let f = uninterpret "fa" :: SArray Integer Integer -> SInteger + noop x = writeArray x 7 (readArray x 7) + constrain $ distinct [a, b, c :: SArray Integer Integer] + pure $ sAnd [f x .== v .&& f (noop x) .== v | (x, v) <- [(a, 3), (b, 4), (c, 5)]]) + -- Same, but the no-op write is in an inner array + , ("ui_fun_nested_array_noop_write", do + let f = uninterpret "fn" :: SArray Integer (ArrayModel Integer Integer) -> SInteger + inner = constArray 1 :: SArray Integer Integer + base = constArray (constArray 0 :: SArray Integer Integer) + pure $ f base .== 2 .&& f (writeArray base 0 inner) .== 1 .&& f (writeArray base 0 (writeArray inner 7 1)) .== 1) + , ("ui_array_index_noop_write", do + a <- free "a"; b <- free "b"; c <- free "c" + let aa = uninterpret "aa" :: SArray (ArrayModel Integer Integer) Integer + noop x = writeArray x 7 (readArray x 7) + constrain $ distinct [a, b, c :: SArray Integer Integer] + pure $ sAnd [readArray aa x .== v .&& readArray aa (noop x) .== v | (x, v) <- [(a, 3), (b, 4), (c, 5)]]) + , ("set_diff_mixed", do s <- free "s"; pure $ S.complement (s :: SSet Integer) `S.difference` S.singleton 1 .== S.complement (S.fromList [1, 2])) + ] + + -- Proofs whose counter-examples should validate + okCex :: [(String, Predicate)] + okCex = [ ("ui_const", pure $ (uninterpret "cp" :: SInteger) .> 3) + , ("ui_fun", do x <- sInteger "x"; pure $ (uninterpret "fc" :: SInteger -> SInteger) x .> x) + ] + + -- Problems whose models we cannot validate, along with the explanation we expect + cant :: [(String, String, Predicate)] + cant = [ ("accessor", "The field accessor getNode_2 is applied to a value built with the constructor Leaf", + do e <- free "e"; pure $ isLeaf e .&& getNode_2 e .== 5) + , ("fromJust", "The field accessor getJust_1 is applied to a value built with the constructor Nothing", + do m <- free "m"; pure $ M.isNothing m .&& M.fromJust m .== (5 :: SInteger)) + , ("head", "Element 0 of a list of length 0 is accessed", + do l <- free "l"; pure $ L.null l .&& L.head l .== (5 :: SInteger)) + , ("ui_smtFun", "The function cnt @(SBV Integer -> SBV Integer) is applied to arguments that depend on uninterpreted values", + do x <- sInteger "x"; pure $ cnt ((uninterpret "f2" :: SInteger -> SInteger) x) .== 2) + , ("lambdaArray", "Arrays created via lambdaArray are not supported concretely", + do i <- sInteger "i"; pure $ readArray (lambdaArray (+ 1)) i .== (5 :: SInteger)) + , ("irrational", "The value depends on an irrational algebraic real", + do x <- sReal "x"; pure $ x * x .== 2) + , ("quantified", "The value depends on a quantified variable", + do x <- sInteger "x"; pure $ quantifiedBool $ \(Forall y) -> x .<= y * y) + -- Equality of arrays with float elements can't be decided concretely, so we must not guess a table entry + , ("ui_fun_undecided", "SBV cannot decide which entry in the model value for the uninterpreted function ff applies to its arguments", + do a <- free "a"; b <- free "b" + let f = uninterpret "ff" :: SArray Integer Float -> SInteger + constrain $ readArray a 0 .== 1 .&& readArray b 0 .== 2 + pure $ f a .== 3 .&& f b .== 4) + , ("array_index_undecided", "SBV cannot decide which entry of the array applies to the index it is read at", + do a <- free "a"; b <- free "b" + let aa = uninterpret "af" :: SArray (ArrayModel Integer Float) Integer + constrain $ readArray a 0 .== 1 .&& readArray b 0 .== 2 + pure $ readArray aa a .== 3 .&& readArray aa b .== 4) + ] + + vcfg = z3{validateModel = True} + + checkSat :: String -> SatResult -> Assertion + checkSat _ (SatResult Satisfiable{}) = pure () + checkSat w r = assertFailure $ "Expected a validated model, got:\n" ++ w ++ "\n" ++ show r + + validates :: Predicate -> Assertion + validates p = satWith vcfg p >>= \r -> checkSat "" r + + validatesP :: Predicate -> Assertion + validatesP p = do r <- proveWith vcfg p + case r of + ThmResult Satisfiable{} -> pure () + _ -> assertFailure $ "Expected a validated counter-example, got:\n" ++ show r + + validatesAll :: (SInteger -> SBool) -> Assertion + validatesAll p = do AllSatResult{allSatResults = rs} <- allSatWith vcfg{allSatMaxModelCount = Just 3} p + assertBool "Expected some models" (not (null rs)) + mapM_ (checkSat "" . SatResult) rs + + cantValidate :: String -> Predicate -> Assertion + cantValidate msg p = do r <- satWith vcfg p + case r of + SatResult ProofError{} | msg `isInfixOf` show r -> pure () + _ -> assertFailure $ "Expected validation failure with: " ++ msg ++ "\nGot:\n" ++ show r + + -- Concrete evaluation of floating-point operations with all rounding modes must match the solver + fpConcrete :: [(String, Assertion)] + fpConcrete = concat [ [ ("float_" ++ show rm, fpChk rm (fpVals :: [(Float, Float, Float)])) + , ("double_" ++ show rm, fpChk rm (fpVals :: [(Double, Double, Double)])) + ] + | rm <- [minBound .. maxBound] + ] + + fpVals :: Fractional a => [(a, a, a)] + fpVals = [ (1, 3, 7), (0.1, 0.2, 0.3), (-1.5, 1e-40, 2.5e-39), (3.4e38, 3.4e38, -1), (1e300, 1e300, 1e-320), (-0, 0, -0), (1/3, 2/3, -(1/3)) ] + + fpChk :: forall a. (IEEEFloating a, SymVal a, Show a) => RoundingMode -> [(a, a, a)] -> Assertion + fpChk rm vals = mapM_ check [ (op, a, b, c) | op <- [0 .. 6 :: Int], (a, b, c) <- vals ] + where srm = literal rm + + f :: Int -> SBV a -> SBV a -> SBV a -> SBV a + f 0 x y _ = fpAdd srm x y + f 1 x y _ = fpSub srm x y + f 2 x y _ = fpMul srm x y + f 3 x y _ = fpDiv srm x y + f 4 x y z = fpFMA srm x y z + f 5 x _ _ = fpSqrt srm x + f _ x _ _ = fpRoundToIntegral srm x + + check (op, a, b, c) = case unliteral (f op (literal a) (literal b) (literal c)) of + Nothing -> assertFailure $ "Not concretely computed: " ++ show (op, a, b, c) + Just r -> do res <- prove $ do x <- free "x"; y <- free "y"; z <- free "z" + constrain $ x .=== literal a .&& y .=== literal b .&& z .=== literal c + pure $ f op x y z .=== literal r + case res of + ThmResult Unsatisfiable{} -> pure () + _ -> assertFailure $ "Concrete result mismatch for " ++ show (op, rm, a, b, c, r) ++ ":\n" ++ show res + + -- Concrete evaluation of overflow checks must match the solver + ovfConcrete :: [(String, Assertion)] + ovfConcrete = [ ("word8", ovfChk (map literal [minBound, 1, 100, 200, maxBound] :: [SWord8])) + , ("int8", ovfChk (map literal [minBound, -1, 0, 1, 100, maxBound] :: [SInt8])) + ] + + ovfChk :: forall a. (SymVal a, Show a, ArithOverflow (SBV a)) => [SBV a] -> Assertion + ovfChk vs = mapM_ check [ (op, a, b) | op <- [0 .. 4 :: Int], a <- vs, b <- vs ] + where f :: Int -> SBV a -> SBV a -> SBool + f 0 = bvAddO + f 1 = bvSubO + f 2 = bvMulO + f 3 = bvDivO + f _ = const . bvNegO + + check (op, a, b) = case unliteral (f op a b) of + Nothing -> assertFailure $ "Not concretely computed: " ++ show (op, a, b) + Just r -> do res <- prove $ do x <- free "x"; y <- free "y" + constrain $ x .== a .&& y .== b + pure $ f op x y .== literal r + case res of + ThmResult Unsatisfiable{} -> pure () + _ -> assertFailure $ "Concrete result mismatch for " ++ show (op, a, b, r) ++ ":\n" ++ show res + + -- Concrete evaluation of set operations on mixed regular/complement sets. We check that + -- the operation folds to the expected value, and that the solver agrees with it. + setConcrete :: [(String, Assertion)] + setConcrete = [ ("union_rc", setChk S.union reg cmp (ComplementSet (Set.fromList [3]))) + , ("union_cr", setChk S.union cmp reg (ComplementSet (Set.fromList [3]))) + , ("intersection_rc", setChk S.intersection reg cmp (RegularSet (Set.fromList [1]))) + , ("intersection_cr", setChk S.intersection cmp reg (RegularSet (Set.fromList [1]))) + , ("difference_rc", setChk S.difference reg cmp (RegularSet (Set.fromList [2]))) + , ("difference_cr", setChk S.difference cmp reg (ComplementSet (Set.fromList [1, 2, 3]))) + , ("difference_cc", setChk S.difference cmp cmp2 (RegularSet (Set.fromList [4]))) + , ("insert_c", setChk (const (S.insert 7)) reg cmp (ComplementSet (Set.fromList [2, 3]))) + , ("delete_c", setChk (const (S.delete 2)) reg cmp (ComplementSet (Set.fromList [2, 3]))) + , ("subset_rc", subsetChk reg False) + , ("subset_rc_true", subsetChk (RegularSet (Set.fromList [1])) True) + ] + where reg, cmp, cmp2 :: RCSet Integer + reg = RegularSet (Set.fromList [1, 2]) -- {1, 2} + cmp = ComplementSet (Set.fromList [2, 3]) -- everything but {2, 3} + cmp2 = ComplementSet (Set.fromList [2, 3, 4]) -- everything but {2, 3, 4} + + is s v = case (unliteral s, v) of + (Just (RegularSet a), RegularSet b) -> a == b + (Just (ComplementSet a), ComplementSet b) -> a == b + _ -> False + + setChk :: (SSet Integer -> SSet Integer -> SSet Integer) -> RCSet Integer -> RCSet Integer -> RCSet Integer -> Assertion + setChk f a b r = do assertBool "Unexpected folded value" (f (literal a) (literal b) `is` r) + onSymbolic a b $ \x y -> f x y .== literal r + + subsetChk :: RCSet Integer -> Bool -> Assertion + subsetChk a r = do assertBool "Unexpected folded value" (unliteral (literal a `S.isSubsetOf` literal cmp) == Just r) + onSymbolic a cmp $ \x y -> (x `S.isSubsetOf` y) .== literal r + + -- Have the solver prove the property, on symbolic sets equal to the given ones + onSymbolic :: RCSet Integer -> RCSet Integer -> (SSet Integer -> SSet Integer -> SBool) -> Assertion + onSymbolic a b p = solverProves $ do x <- free "x"; y <- free "y" + constrain $ x .== literal a .&& y .== literal b + pure $ p x y + + -- Concrete equality of arrays must compare values, not representations. When we decide + -- concretely, we also check that the solver agrees. + arrConcrete :: [(String, Assertion)] + arrConcrete = [ ("noop_write_eq", arrChk arr (writeArray arr 7 (readArray arr 7)) (Just True)) + , ("noop_write_eq2", arrChk (writeArray arr 7 10) arr (Just True)) + , ("write_neq", arrChk (writeArray arr 7 11) arr (Just False)) + , ("write_neq2", arrChk (writeArray arr 2 10) arr (Just False)) + -- Nested arrays are compared by value, not by representation + , ("nested_noop_eq", arrChk (writeArray outer 0 arr) (writeArray outer 0 (writeArray arr 7 10)) (Just True)) + , ("nested_neq", arrChk (writeArray outer 0 arr) (writeArray outer 0 (writeArray arr 7 11)) (Just False)) + -- Different defaults: If some index is in neither table, it maps to the defaults, so the arrays differ + , ("defaults_neq_infinite", arrChk (constArray 0) (constArray 1 :: SArray Integer Integer) (Just False)) + , ("defaults_neq_finite", arrChk (constArray 0) (constArray 1 :: SArray Word8 Integer) (Just False)) + -- Over a finite index type, if the keys of the tables together cover it, defaults don't matter + , ("bool_split_cover_eq", arrChk (listArray [(False, 1)] 2) (listArray [(True, 2)] 1 :: SArray Bool Integer) (Just True)) + , ("bool_split_cover_neq", arrChk (listArray [(False, 1)] 2) (listArray [(True, 3)] 1 :: SArray Bool Integer) (Just False)) + , ("bool_uncovered_neq", arrChk (listArray [(False, 1)] 0) (listArray [(False, 1)] 5 :: SArray Bool Integer) (Just False)) + , ("enum_cover_eq", arrChk (constArray 0) (listArray [(A, 0), (B, 0), (C, 0)] 1 :: SArray E Integer) (Just True)) + , ("enum_uncovered_neq", arrChk (constArray 0) (listArray [(A, 0), (B, 0)] 1 :: SArray E Integer) (Just False)) + -- We can't count the elements of a tuple index type, so we can't tell + , ("defaults_neq_unknown", arrChk (constArray 0) (constArray 1 :: SArray (Bool, Bool) Integer) Nothing) + ] + where arr :: SArray Integer Integer + arr = listArray [(2, 7)] 10 + + outer :: SArray Integer (ArrayModel Integer Integer) + outer = constArray (literal (ArrayModel [] 0)) + + arrChk :: (SymVal a, SymVal b) => SArray a b -> SArray a b -> Maybe Bool -> Assertion + arrChk a b r = do assertBool ("Unexpected folded value: " ++ show (unliteral (a .== b))) (unliteral (a .== b) == r) + case r of + Nothing -> pure () + Just v -> solverProves $ do x <- free "x"; y <- free "y" + constrain $ x .== a .&& y .== b + pure $ (x .== y) .== literal v + + -- Make sure the solver proves the given predicate + solverProves :: Predicate -> Assertion + solverProves p = do r <- prove p + case r of + ThmResult Unsatisfiable{} -> pure () + _ -> assertFailure $ "Solver disagrees with the concrete result:\n" ++ show r + + -- Regression test for a z3 bug that returned an invalid model here. + -- See: https://github.com/Z3Prover/z3/issues/7664 + t6 :: Assertion + t6 = do r <- satWith z3 $ do xs <- free "xs" + pure $ L.length (L.concat (xs :: SList String)) .>= 5 + case getModelValue "xs" r of + Just (xs :: [String]) -> assertBool ("Model is too short: " ++ show xs) (length (concat xs) >= 5) + Nothing -> assertFailure $ "No model for xs:\n" ++ show r diff --git a/SBVTestSuite/TestSuite/CompileTests/PCase/PCase17.stderr b/SBVTestSuite/TestSuite/CompileTests/PCase/PCase17.stderr --- a/SBVTestSuite/TestSuite/CompileTests/PCase/PCase17.stderr +++ b/SBVTestSuite/TestSuite/CompileTests/PCase/PCase17.stderr @@ -15,8 +15,8 @@ (isLet e ==> (e .== e =: qed))] PCase17.hs:18:14: error: [GHC-83865] " Couldn't match expected type: Proof SBool - with actual type: sbv-14.8:Data.SBV.TP.TP.TPProofGen - (SBV Bool) [sbv-14.8:Data.SBV.TP.TP.Helper] () + with actual type: sbv-14.9:Data.SBV.TP.TP.TPProofGen + (SBV Bool) [sbv-14.9:Data.SBV.TP.TP.Helper] () " In the expression: cases [(isZero e ==> (e .== e =: qed)), (isNum e ==> (e .== e =: qed)), diff --git a/SBVTestSuite/TestSuite/CompileTests/PCase/PCase38.stderr b/SBVTestSuite/TestSuite/CompileTests/PCase/PCase38.stderr --- a/SBVTestSuite/TestSuite/CompileTests/PCase/PCase38.stderr +++ b/SBVTestSuite/TestSuite/CompileTests/PCase/PCase38.stderr @@ -15,8 +15,8 @@ (isLet e ==> undefined)] PCase38.hs:12:14: error: [GHC-83865] " Couldn't match expected type: Proof SBool - with actual type: sbv-14.8:Data.SBV.TP.TP.TPProofGen - a0 [sbv-14.8:Data.SBV.TP.TP.Helper] () + with actual type: sbv-14.9:Data.SBV.TP.TP.TPProofGen + a0 [sbv-14.9:Data.SBV.TP.TP.Helper] () " In the expression: cases [(isZero e ==> undefined), (isNum e ==> undefined), diff --git a/SBVTestSuite/TestSuite/CompileTests/SCase/SCase101.stderr b/SBVTestSuite/TestSuite/CompileTests/SCase/SCase101.stderr --- a/SBVTestSuite/TestSuite/CompileTests/SCase/SCase101.stderr +++ b/SBVTestSuite/TestSuite/CompileTests/SCase/SCase101.stderr @@ -28,4 +28,4 @@ ((\ _ -> 1) (Data.SBV.Maybe.getJust_1 m)) (ite (Data.SBV.Maybe.isNothing m) 0 - (symWithKind "unmatched_sCase_Maybe_6989586621679035188"))) + (symWithKind "unmatched_sCase_Maybe_6989586621679035172"))) diff --git a/SBVTestSuite/TestSuite/CompileTests/SCase/SCase59.stderr b/SBVTestSuite/TestSuite/CompileTests/SCase/SCase59.stderr --- a/SBVTestSuite/TestSuite/CompileTests/SCase/SCase59.stderr +++ b/SBVTestSuite/TestSuite/CompileTests/SCase/SCase59.stderr @@ -24,4 +24,4 @@ ((\ _ -> Data.SBV.Either.isRight (Data.SBV.Maybe.getJust_1 m)) (Data.SBV.Maybe.getJust_1 m))) ((\ _ -> 1) (Data.SBV.Maybe.getJust_1 m)) - (symWithKind "unmatched_sCase_Maybe_6989586621679035188"))) + (symWithKind "unmatched_sCase_Maybe_6989586621679035172"))) diff --git a/SBVTestSuite/TestSuite/CompileTests/SCase/SCase66.stderr b/SBVTestSuite/TestSuite/CompileTests/SCase/SCase66.stderr --- a/SBVTestSuite/TestSuite/CompileTests/SCase/SCase66.stderr +++ b/SBVTestSuite/TestSuite/CompileTests/SCase/SCase66.stderr @@ -30,4 +30,4 @@ (ite (Data.SBV.Either.isRight e) ((\ _ -> 1) (Data.SBV.Either.getRight_1 e)) - (symWithKind "unmatched_sCase_Either_6989586621679035150"))) + (symWithKind "unmatched_sCase_Either_6989586621679035134"))) diff --git a/SBVTestSuite/TestSuite/CompileTests/SCase/SCase89.stderr b/SBVTestSuite/TestSuite/CompileTests/SCase/SCase89.stderr --- a/SBVTestSuite/TestSuite/CompileTests/SCase/SCase89.stderr +++ b/SBVTestSuite/TestSuite/CompileTests/SCase/SCase89.stderr @@ -40,4 +40,4 @@ (isVar e) ((\ _ -> 1) (getVar_1 e)) (ite (isLet e) ((\ _ _ _ -> 3) (getLet_1 e) (getLet_2 e) (getLet_3 e)) - (symWithKind "unmatched_sCase_Expr_6989586621679080842")))))) + (symWithKind "unmatched_sCase_Expr_6989586621679080836")))))) diff --git a/SBVTestSuite/TestSuite/Puzzles/Rubik.hs b/SBVTestSuite/TestSuite/Puzzles/Rubik.hs new file mode 100644 --- /dev/null +++ b/SBVTestSuite/TestSuite/Puzzles/Rubik.hs @@ -0,0 +1,268 @@ +----------------------------------------------------------------------------- +-- | +-- Module : TestSuite.Puzzles.Rubik +-- Copyright : (c) Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Tests for the concrete geometry, symbolic lifting, and bounded shortest +-- and two-phase search. +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module TestSuite.Puzzles.Rubik(tests) where + +import Control.Exception (ErrorCall, try) +import Control.Monad (forM_, replicateM) +import Data.List (isInfixOf, sort, sortOn) +import qualified Data.List as List (foldl') +import qualified Data.Map.Strict as Map +import qualified Data.Set as Set + +import Documentation.SBV.Examples.Puzzles.Rubik +import Utils.SBVTestFramework + +tests :: TestTree +tests = testGroup "Puzzles.Rubik" + [ testCase "permutations and identities" concrete + , testCase "Kociemba fixtures" fixtures + , testCase "canonical coverage through depth 3" canonicalCoverage + , testCase "notation" notation + , testCase "symbolic transitions, all 18 moves" symbolicTransitions + , testCase "symbolic lifting identities" symbolicIdentities + , testCase "solved and zero bound" zeroBounds + , testCase "negative depth bound" invalidOptions + , testCase "all one-move scrambles" singleMoves + , testCase "shortest distances with and without pruning" shortest + , testCase "phase-one target and projection" phaseOneTarget + , testCase "two-phase solutions and bounds" twoPhaseSearch + , testCase "bounded search with inactive suffix" boundedSearch + ] + +labels :: [Int] +labels = [0..53] + +turnLabels :: [Move] -> [Int] +turnLabels = List.foldl' (\xs m -> permute (movePerm m) xs) labels + +concrete :: Assertion +concrete = do + forM_ allMoves $ \m -> do + let p = permute (movePerm m) labels + assert (sort p == labels) + assert (all (\i -> p !! i == i) [4,13,22,31,40,49]) + assert (turnLabels [m, inverseMove m] == labels) + forM_ [U,D,L,R,F,B] $ \f -> do + assert (turnLabels (replicate 4 (Move f Clockwise)) == labels) + assert (turnLabels (replicate 2 (Move f HalfTurn)) == labels) + forM_ [(U,D),(L,R),(F,B)] $ \(f,g) -> + forM_ [(t,u) | t <- [Clockwise,HalfTurn,Counterclockwise], u <- [Clockwise,HalfTurn,Counterclockwise]] $ \(t,u) -> + assert (turnLabels [Move f t, Move g u] == turnLabels [Move g u, Move f t]) + let scramble = [Move R Clockwise, Move B HalfTurn, Move D Counterclockwise, Move L Clockwise, Move F HalfTurn] + assert (isSolved (applyMoves (invertMoves scramble) (applyMoves scramble solvedCube))) + assert (turnLabels (scramble ++ invertMoves scramble) == labels) + +-- Independently published source-to-destination tables, transcribed from +-- https://kociemba.org/math/CubeDefs.htm (FaceletMove). Convert explicitly to +-- our destination-to-source convention. These expected values do not call +-- the geometry generator, and distinguish every sticker, including centers. +fixtures :: Assertion +fixtures = forM_ tables $ \(face, rows) -> do + let names = [f : show i | f <- "URFDLB", i <- [1::Int ..9]] + indexes = Map.fromList (zip names labels) + destinations = map (indexes Map.!) (words (unwords rows)) + sources = map fst (sortOn snd (zip labels destinations)) + assert (sort destinations == labels) + assert (turnLabels [Move face Clockwise] == sources) + where tables = + [ (U, [ "U3 U6 U9 U2 U5 U8 U1 U4 U7", "F1 F2 F3 R4 R5 R6 R7 R8 R9" + , "L1 L2 L3 F4 F5 F6 F7 F8 F9", "D1 D2 D3 D4 D5 D6 D7 D8 D9" + , "B1 B2 B3 L4 L5 L6 L7 L8 L9", "R1 R2 R3 B4 B5 B6 B7 B8 B9" ]) + , (R, [ "U1 U2 B7 U4 U5 B4 U7 U8 B1", "R3 R6 R9 R2 R5 R8 R1 R4 R7" + , "F1 F2 U3 F4 F5 U6 F7 F8 U9", "D1 D2 F3 D4 D5 F6 D7 D8 F9" + , "L1 L2 L3 L4 L5 L6 L7 L8 L9", "D9 B2 B3 D6 B5 B6 D3 B8 B9" ]) + , (F, [ "U1 U2 U3 U4 U5 U6 R1 R4 R7", "D3 R2 R3 D2 R5 R6 D1 R8 R9" + , "F3 F6 F9 F2 F5 F8 F1 F4 F7", "L3 L6 L9 D4 D5 D6 D7 D8 D9" + , "L1 L2 U9 L4 L5 U8 L7 L8 U7", "B1 B2 B3 B4 B5 B6 B7 B8 B9" ]) + , (D, [ "U1 U2 U3 U4 U5 U6 U7 U8 U9", "R1 R2 R3 R4 R5 R6 B7 B8 B9" + , "F1 F2 F3 F4 F5 F6 R7 R8 R9", "D3 D6 D9 D2 D5 D8 D1 D4 D7" + , "L1 L2 L3 L4 L5 L6 F7 F8 F9", "B1 B2 B3 B4 B5 B6 L7 L8 L9" ]) + , (L, [ "F1 U2 U3 F4 U5 U6 F7 U8 U9", "R1 R2 R3 R4 R5 R6 R7 R8 R9" + , "D1 F2 F3 D4 F5 F6 D7 F8 F9", "B9 D2 D3 B6 D5 D6 B3 D8 D9" + , "L3 L6 L9 L2 L5 L8 L1 L4 L7", "B1 B2 U7 B4 B5 U4 B7 B8 U1" ]) + , (B, [ "L7 L4 L1 U4 U5 U6 U7 U8 U9", "R1 R2 U1 R4 R5 U2 R7 R8 U3" + , "F1 F2 F3 F4 F5 F6 F7 F8 F9", "D1 D2 D3 D4 D5 D6 R9 R6 R3" + , "D7 L2 L3 D8 L5 L6 D9 L8 L9", "B3 B6 B9 B2 B5 B8 B1 B4 B7" ]) + ] + +canonicalCoverage :: Assertion +canonicalCoverage = forM_ [0..3] $ \n -> do + let sequences = concatMap (`replicateM` allMoves) [0..n] + canonical ms = and [f /= g && (f,g) `notElem` [(D,U),(R,L),(B,F)] + | (Move f _, Move g _) <- zip ms (drop 1 ms)] + reachable = Set.fromList . map turnLabels + assert (reachable sequences == reachable (filter canonical sequences)) + -- Also tie the concrete reference predicate to the symbolic pruning rule. + forM_ [(a,b) | a <- allMoves, b <- allMoves] $ \(a,b) -> + assert (unliteral (canonicalPair (symbolicMove a) (symbolicMove b)) == Just (canonical [a,b])) + +notation :: Assertion +notation = do + assert (parseMoves (renderMoves allMoves) == Right allMoves) + assert (parseMoves " \t\n " == Right []) + assert (parseMoves " R\t U2\nF' " == Right [Move R Clockwise, Move U HalfTurn, Move F Counterclockwise]) + forM_ [("r", "wide"), ("M2", "slice"), ("E", "slice"), ("S'", "slice") + ,("x", "rotation"), ("y2", "rotation"), ("z'", "rotation"), ("Rw", "wide"), ("Fw2", "wide") + ,("R2'", "use R2"), ("R,U", "whitespace"), ("R;U", "whitespace") + ,("Q", "expected"), ("R3", "expected"), ("R''", "expected"), ("W", "expected"), ("white", "expected")] $ \(token, hint) -> + case parseMoves ("U " ++ token) of + Left err -> assert (all (`isInfixOf` err) ["Token 2", show token, hint]) + Right ms -> assertFailure ("Unexpected parse: " ++ show ms) + assert (renderMoves [] == "") + -- A solved net is a deterministic formatting fixture; no solver model golden. + assert (renderCube solvedCube == unlines + [" U", " w w w", " w w w", " w w w", "L F R B" + ,"o o o g g g r r r b b b", "o o o g g g r r r b b b", "o o o g g g r r r b b b" + ," D", " y y y", " y y y", " y y y" + ,"w=white r=red g=green y=yellow o=orange b=blue"]) + +symbolicMove :: Move -> SMove +symbolicMove (Move f t) = SMove (literal f) (literal t) + +symbolicTransitions :: Assertion +symbolicTransitions = assertIsThm $ do + cs <- mapM (free . ("color_" ++) . show) [0::Int ..53] + f <- free "face" + t <- free "turn" + let m = SMove f t + -- Arbitrary symbolic colors make this stronger than fixing a sample cube. + pure $ sAnd [(f .== literal face .&& t .== literal turn) + .=> (step m cs .== permute (movePerm move) cs) + | move@(Move face turn) <- allMoves] + +symbolicIdentities :: Assertion +symbolicIdentities = assertIsThm $ do + cs <- mapM (free . ("color_" ++) . show) [0::Int ..53] + -- These can simplify before reaching the solver: they check the lifting. + pure $ sAnd [step (symbolicMove (inverseMove m)) (step (symbolicMove m) cs) .== cs | m <- allMoves] + +zeroBounds :: Assertion +zeroBounds = do + solved <- solveScramble (defaultOptions 0) [] + assert (solved == Solved []) + unsolved <- solveScramble (defaultOptions 0) [Move F Clockwise] + assert (unsolved == NoSolutionWithin 0) + +invalidOptions :: Assertion +invalidOptions = do + result <- try (solveScramble (defaultOptions (-1)) []) :: IO (Either ErrorCall SolveResult) + case result of + Left _ -> pure () + Right r -> assertFailure ("Accepted invalid options: " ++ show r) + +singleMoves :: Assertion +singleMoves = forM_ allMoves $ \m -> do + result <- solveScramble (defaultOptions 1) [m] + assert (result == Solved [inverseMove m]) + +-- Independent, unpruned breadth-first search on concrete color states. Its +-- expected distances come from visited layers, never from scramble lengths. +bfs :: Int -> Map.Map Cube Int +bfs limit = go 0 (Set.singleton solvedCube) (Map.singleton solvedCube 0) + where go depth frontier seen + | depth == limit = seen + | True = + let next = Set.fromList [applyMove m c | c <- Set.toList frontier, m <- allMoves] + `Set.difference` Map.keysSet seen + seen' = Map.union seen (Map.fromSet (const (depth+1)) next) + in go (depth+1) next seen' + +shortest :: Assertion +shortest = do + let distances = bfs 3 + scrambles = [[], [Move R Clockwise, Move R Counterclockwise] + ,[Move R Clockwise, Move R Clockwise] + ,[Move R Clockwise, Move L Clockwise, Move R Clockwise] + ,[Move U Clockwise, Move F HalfTurn] + ,[Move R Clockwise, Move U Clockwise, Move F HalfTurn]] + forM_ scrambles $ \scramble -> do + let initial = applyMoves scramble solvedCube + distance = distances Map.! initial + forM_ [False,True] $ \pruning -> do + let opts = (defaultOptions distance) {usePruning = pruning} + result <- solveWith z3 opts initial + case result of + Solved ms -> assert (length ms == distance && isSolved (applyMoves ms initial)) + other -> assertFailure (show other) + if distance == 0 then pure () else do + below <- solveWith z3 opts {maxDepth = distance-1} initial + assert (below == NoSolutionWithin (distance-1)) + +-- The reference uses Kociemba's corner/edge facelet groups, checking the +-- orientations and slice membership separately on full colors. In particular, +-- orienting just the corners or just the U/D edges is insufficient. +phaseOneTarget :: Assertion +phaseOneTarget = do + let corners :: [(Int, Int, Int)] + corners = [(8,9,20), (6,18,38), (0,36,47), (2,45,11) + ,(29,26,15), (27,44,24), (33,53,42), (35,17,51)] + edges = [(5,10), (7,19), (3,37), (1,46), (32,16), (28,25) + ,(30,43), (34,52), (23,12), (21,41), (50,39), (48,14)] + ud c = c `elem` [White,Yellow] + fb c = c `elem` [Green,Blue] + reference (Cube cs) = all (\(i,_,_) -> ud (cs !! i)) corners + && all (\(i,j) -> ud (cs !! i) || (fb (cs !! i) && not (ud (cs !! j)))) edges + && not (any (\(i,j) -> ud (cs !! i) || ud (cs !! j)) (drop 8 edges)) + ready = unliteral . phaseOneGoal . map literal . cubeColors . phaseOneCube + states = solvedCube : map (`applyMove` solvedCube) allMoves + forM_ states $ \cube -> do + assert (ready cube == Just (reference cube)) + forM_ allMoves $ \m -> + assert (phaseOneCube (applyMove m cube) == applyMove m (phaseOneCube cube)) + -- Check every restricted move preserves the target, including on a state + -- with the correct orientations but permuted pieces. + let permuted = applyMoves [Move U Clockwise, Move F HalfTurn, Move D Counterclockwise] solvedCube + forM_ [solvedCube, permuted] $ \cube -> + forM_ phaseTwoMoves $ \m -> assert (ready (applyMove m cube) == Just True) + assert (ready (applyMove (Move R Clockwise) solvedCube) == Just False) + assert (ready (applyMove (Move F Clockwise) solvedCube) == Just False) + +twoPhaseSearch :: Assertion +twoPhaseSearch = do + -- One tiny scramble exercises both phases. Hard cubes are manual examples, + -- not regression tests; keep these bounds at one and two moves. + let initial = applyMoves [Move U Clockwise, Move R Clockwise] solvedCube + result <- solveTwoPhase (defaultOptions 1) (defaultOptions 2) initial + case result of + TwoPhaseSolved first second -> do + assert (length first <= 1 && length second <= 2) + assert (all (`elem` phaseTwoMoves) second) + assert (unliteral (phaseOneGoal (map literal (cubeColors (phaseOneCube (applyMoves first initial))))) == Just True) + assert (isSolved (applyMoves (first ++ second) initial)) + other -> assertFailure (show other) + solved <- solveTwoPhaseWith z3 (defaultOptions 0) (defaultOptions 0) solvedCube + assert (solved == TwoPhaseSolved [] []) + firstFailed <- solveTwoPhaseWith z3 (defaultOptions 0) (defaultOptions 2) (applyMove (Move R Clockwise) solvedCube) + assert (firstFailed == PhaseOneExhausted 0) + secondFailed <- solveTwoPhaseWith z3 (defaultOptions 0) (defaultOptions 0) (applyMove (Move U Clockwise) solvedCube) + assert (secondFailed == PhaseTwoExhausted [] 0) + forM_ [(-1,0), (0,-1)] $ \(a,b) -> do + invalid <- try (solveTwoPhaseWith z3 (defaultOptions a) (defaultOptions b) solvedCube) :: IO (Either ErrorCall TwoPhaseResult) + case invalid of + Left _ -> pure () + Right r -> assertFailure ("Accepted invalid phase bounds: " ++ show r) + +-- A one-move solution must fit a larger bound even when canonical pruning +-- prevents extending the active sequence with the only permitted move. +boundedSearch :: Assertion +boundedSearch = do + let goal cs = cs .== map literal (cubeColors solvedCube) + move = Move R Clockwise + initial = applyMove (inverseMove move) solvedCube + result <- solveWithinWith z3 (defaultOptions 3) [move] goal initial + assert (result == Solved [move]) + impossible <- solveWithinWith z3 (defaultOptions 3) [] goal initial + assert (impossible == NoSolutionWithin 3) + diff --git a/SBVTestSuite/Utils/SBVTestFramework.hs b/SBVTestSuite/Utils/SBVTestFramework.hs --- a/SBVTestSuite/Utils/SBVTestFramework.hs +++ b/SBVTestSuite/Utils/SBVTestFramework.hs @@ -165,8 +165,8 @@ ] model = case result of - Right v -> showModel defaultSMTCfg (SMTModel [] Nothing (vals ++ [getCV "Result" (literal v)]) []) - Left e -> showModel defaultSMTCfg (SMTModel [] Nothing vals []) ++ "\n" ++ e + Right v -> showModel defaultSMTCfg (SMTModel [] Nothing (vals ++ [getCV "Result" (literal v)]) [] Nothing) + Left e -> showModel defaultSMTCfg (SMTModel [] Nothing vals [] Nothing) ++ "\n" ++ e QC.monitor (QC.counterexample model) @@ -213,8 +213,8 @@ ] model = case result of - Right v -> showModel defaultSMTCfg (SMTModel [] Nothing (vals ++ [getCV "Result" (literal v)]) []) - Left e -> showModel defaultSMTCfg (SMTModel [] Nothing vals []) ++ "\n" ++ e + Right v -> showModel defaultSMTCfg (SMTModel [] Nothing (vals ++ [getCV "Result" (literal v)]) [] Nothing) + Left e -> showModel defaultSMTCfg (SMTModel [] Nothing vals [] Nothing) ++ "\n" ++ e QC.monitor (QC.counterexample model) diff --git a/sbv.cabal b/sbv.cabal --- a/sbv.cabal +++ b/sbv.cabal @@ -1,7 +1,7 @@ Cabal-Version: 2.2 Name : sbv -Version : 14.8 +Version : 14.9 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 @@ -234,6 +234,7 @@ , Documentation.SBV.Examples.Puzzles.NQueens , Documentation.SBV.Examples.Puzzles.Orangutans , Documentation.SBV.Examples.Puzzles.Rabbits + , Documentation.SBV.Examples.Puzzles.Rubik , Documentation.SBV.Examples.Puzzles.SendMoreMoney , Documentation.SBV.Examples.Puzzles.SquareBirthday , Documentation.SBV.Examples.Puzzles.Sudoku @@ -261,6 +262,7 @@ , Documentation.SBV.Examples.TP.Countdown , Documentation.SBV.Examples.TP.Fibonacci , Documentation.SBV.Examples.TP.GCD + , Documentation.SBV.Examples.TP.Huffman , Documentation.SBV.Examples.TP.InsertionSort , Documentation.SBV.Examples.TP.Kadane , Documentation.SBV.Examples.TP.Kleene @@ -492,6 +494,7 @@ , TestSuite.Puzzles.MagicSquare , TestSuite.Puzzles.NQueens , TestSuite.Puzzles.PowerSet + , TestSuite.Puzzles.Rubik , TestSuite.Puzzles.Sudoku , TestSuite.Puzzles.Temperature , TestSuite.Puzzles.U2Bridge