packages feed

sbv 8.6 → 8.7

raw patch · 231 files changed

+7541/−4376 lines, 231 filesdep +gaugedep +silentlydep −criteriondep −ghc

Dependencies added: gauge, silently

Dependencies removed: criterion, ghc

Files

CHANGES.md view
@@ -1,8 +1,59 @@ * Hackage: <http://hackage.haskell.org/package/sbv> * GitHub:  <http://leventerkok.github.com/sbv/> -* Latest Hackage released version: 8.6, 2020-02-08+* Latest Hackage released version: 8.7, 2020-06-30 +### Version 8.7, 2020-06-30++  * Add support for concurrent versions of solvers for query+    problems. Similar to 'satWithAny', 'proveWithAny' etc.,+    except when we have queries. Thanks to Jeffrey Young+    for the idea and the implementation.++  * Add "Documentation.SBV.Examples.Misc.Newtypes", demonstrating+    how to use newtypes over existing symbolic types as+    symbolic quantities themselves. Thanks to Curran McConnell+    for the example.++  * Added new predicate `sNotElem`, negating `sElem`.++  * Added new predicate `distinctExcept`. This is same as `distinct`+    except you can also provide an ignore list. The elements in+    the first list will be checked to be distinct from each other,+    or belong to the second list. This is good for writing constraints+    that either require a default value or if picked be different+    from each other for a set of variables. This sort of constraint+    can be coded in user space, but SBV generates efficient code+    instead of the obvious quadratic number of constraints.++  * Add function 'algRealToRational' that can convert an algebraic-real+    to a Haskell rational. We get an either value: If the algebraic real+    is exact, then it returns a 'Left' value that represents the value+    precisely. Otherwise, it returns a 'Right' value, which is only+    an approximation. Note: Setting 'printRealPrec' in SMTConfig+    to a higher value will increase the precision at the cost of more+    computation by the SMT solver.++  * Removed the 'SMTValue' class. It's functionality was not really+    needed. If you ever used this class, removing it from your+    type signatures should fix the issue. (You might have to+    add SymVal constraint if you did not already have it.) Please+    get in touch if you used this class in some cunning way and you+    need its functionality back.++  * Reworked SBVBenchSuite api, Phase 1 of BenchSuite completed.+  +  * Add support for addAxiom command to work in the interactive mode.+    Thanks to Martin Lundfall for the feedback.++  * Fixed `proveWithAny` and `satWithAny` functions so they properly+    kill the solvers that did not terminate first. Previously, they+    became zombies if they didn't end up quickly. Thanks to+    Robert Dockins for the investigation and the fix.++  * Fixed a bug where resetAssertions call was forgetting to restore the+    array and table contexts. Thanks to Martin Lundfall for reporting.+ ### Version 8.6, 2020-02-08    * Fix typo in error message. Thanks to Oliver Charles@@ -324,7 +375,7 @@     then your float value will be minimized as the corresponding 32 (or 64 for     doubles) bit word. Note that this methods supports infinities properly, and     does not distinguish between -0 and +0.-    +   * Optimization routines have been generalized to work over arbitrary metric-spaces,     with user-definable mappings. The simplest instance we have added is optimization     over booleans, by the obvious numeric mapping. Tuples are also supported with@@ -394,7 +445,7 @@         * Existential  : bAny    became   sAny         * Universal    : bAll    became   sAll -  * [BACKWARDS COMPATIBILITY, INTERNAL] Hostorically, SBV focused on bit-vectors and machine+  * [BACKWARDS COMPATIBILITY, INTERNAL] Historically, SBV focused on bit-vectors and machine     words, which meant lots of internal types were named suggestive of this heritage.     With the addition of `SInteger`, `SReal`, `SFloat`, `SDouble` we have expanded     this, but still remained focused on atomic types. But, thanks largely to@@ -1860,7 +1911,7 @@  ### Version 2.9, 2013-01-02 -  * Add support for the CVC4 SMT solver from Stanford: <http://cvc4.cs.stanford.edu/web/>+  * Add support for the CVC4 SMT solver from Stanford: <https://cvc4.github.io/>     NB. Z3 remains the default solver for SBV. To use CVC4, use the     *With variants of the interface (i.e., proveWith, satWith, ..)     by passing cvc4 as the solver argument. (Similarly, use 'yices'
Data/SBV.hs view
@@ -108,7 +108,7 @@ -- --   * ABC from University of Berkeley: <http://www.eecs.berkeley.edu/~alanmi/abc/> -----   * CVC4 from Stanford: <http://cvc4.cs.stanford.edu/web/>+--   * CVC4 from Stanford: <https://cvc4.github.io/> -- --   * Boolector from Johannes Kepler University: <http://fmv.jku.at/boolector/> --@@ -156,7 +156,7 @@   , SFloat, SDouble   -- ** Algebraic reals   -- $algReals-  , SReal, AlgReal, sRealToSInteger+  , SReal, AlgReal, sRealToSInteger, algRealToRational   -- ** Characters, Strings and Regular Expressions   -- $strings   , SChar, SString@@ -242,7 +242,7 @@   -- $enumerations   , mkSymbolicEnumeration -  -- * Uninterpreted sorts, constants, and functions+  -- * Uninterpreted sorts, axioms, constants, and functions   -- $uninterpreted   , Uninterpreted(..), addAxiom @@ -255,6 +255,7 @@   , satWith, allSat, allSatWith, optimize, optimizeWith, isVacuous   , isVacuousWith, isTheorem, isTheoremWith, isSatisfiable, isSatisfiableWith   , proveWithAll, proveWithAny, satWithAll+  , proveConcurrentWithAny, proveConcurrentWithAll, satConcurrentWithAny, satConcurrentWithAll   , satWithAny, generateSMTBenchmark   , solve   -- * Constraints@@ -346,7 +347,7 @@   ) where  import Data.SBV.Core.AlgReals-import Data.SBV.Core.Data       hiding (addAxiom, forall, forall_,+import Data.SBV.Core.Data       hiding (forall, forall_,                                         mkForallVars, exists, exists_,                                         mkExistVars, free, free_, mkFreeVars,                                         output, symbolic, symbolics, mkSymVal,
Data/SBV/Client.hs view
@@ -33,7 +33,6 @@  import Data.SBV.Core.Data import Data.SBV.Core.Model-import Data.SBV.Control.Utils import Data.SBV.Provers.Prover  -- | Check whether the given solver is installed and is ready to go. This call does a@@ -69,6 +68,5 @@         deriving instance Data     $(typeCon)         deriving instance SymVal   $(typeCon)         deriving instance HasKind  $(typeCon)-        deriving instance SMTValue $(typeCon)         deriving instance SatModel $(typeCon)       |]
Data/SBV/Client/BaseIO.hs view
@@ -765,16 +765,6 @@ svToSymSV :: SVal -> Symbolic SV svToSymSV = Trans.svToSymSV --- | Add a user specified axiom to the generated SMT-Lib file. The first argument is a mere--- string, use for commenting purposes. The second argument is intended to hold the multiple-lines--- of the axiom text as expressed in SMT-Lib notation. Note that we perform no checks on the axiom--- itself, to see whether it's actually well-formed or is sensical by any means.--- A separate formalization of SMT-Lib would be very useful here.------ NB. For a version which generalizes over the underlying monad, see 'Data.SBV.Trans.addAxiom'-addAxiom :: String -> [String] -> Symbolic ()-addAxiom = Trans.addAxiom- -- | Run a symbolic computation, and return a extra value paired up with the 'Result' -- -- NB. For a version which generalizes over the underlying monad, see 'Data.SBV.Trans.runSymbolic'
Data/SBV/Control.hs view
@@ -30,7 +30,7 @@       -- * Querying the solver      -- ** Extracting values-     , SMTValue(..), getValue, registerUISMTFunction, getFunction, getUninterpretedValue, getModel, getAssignment, getSMTResult, getUnknownReason, getObservables+     , getValue, registerUISMTFunction, getFunction, getUninterpretedValue, getModel, getAssignment, getSMTResult, getUnknownReason, getObservables       -- ** Extracting the unsat core      , getUnsatCore@@ -94,7 +94,7 @@                                       , freshArray, freshArray_, checkSat, ensureSat                                       , checkSatUsing, getValue                                       , getUninterpretedValue, timeout, io)-import Data.SBV.Control.Utils (SMTValue, registerUISMTFunction)+import Data.SBV.Control.Utils (registerUISMTFunction)  import Data.SBV.Utils.ExtractIO (ExtractIO(..))
Data/SBV/Control/BaseIO.hs view
@@ -17,7 +17,6 @@  import Data.SBV.Control.Query (Assignment) import Data.SBV.Control.Types (CheckSatResult, SMTInfoFlag, SMTInfoResponse, SMTOption, SMTReasonUnknown)-import Data.SBV.Control.Utils (SMTValue) import Data.SBV.Core.Concrete (CV) import Data.SBV.Core.Data     (HasKind, Symbolic, SymArray, SymVal, SBool, SBV, SBVType) import Data.SBV.Core.Symbolic (Query, QueryContext, QueryState, State, SMTModel, SMTResult, SV)@@ -427,7 +426,7 @@ -- | Get the value of a term. -- -- NB. For a version which generalizes over the underlying monad, see 'Data.SBV.Trans.Control.getValue'-getValue :: SMTValue a => SBV a -> Query a+getValue :: SymVal a => SBV a -> Query a getValue = Trans.getValue  -- | Get the value of an uninterpreted sort, as a String@@ -439,7 +438,7 @@ -- | Get the value of an uninterpreted function, as a list of domain, value pairs. -- The final value is the "else" clause, i.e., what the function maps values outside -- of the domain of the first list.-getFunction :: Trans.SMTFunction fun a r => fun -> Query ([(a, r)], r)+getFunction :: (SymVal a, SymVal r, Trans.SMTFunction fun a r) => fun -> Query ([(a, r)], r) getFunction = Trans.getFunction  -- | Get the value of a term. If the kind is Real and solver supports decimal approximations,
Data/SBV/Control/Query.hs view
@@ -483,33 +483,18 @@ -- | Upon a pop, we need to restore all arrays and tables. See: http://github.com/LeventErkok/sbv/issues/374 restoreTablesAndArrays :: (MonadIO m, MonadQuery m) => m () restoreTablesAndArrays = do st <- queryState-                            qs <- getQueryState -                            case queryTblArrPreserveIndex qs of-                              Nothing       -> return ()-                              Just (tc, ac) -> do tCount <- M.size  <$> (io . readIORef) (rtblMap   st)-                                                  aCount <- IM.size <$> (io . readIORef) (rArrayMap st)--                                                  let tInits = [ "table"  ++ show i ++ "_initializer" | i <- [tc .. tCount - 1]]-                                                      aInits = [ "array_" ++ show i ++ "_initializer" | i <- [ac .. aCount - 1]]-                                                      inits  = tInits ++ aInits--                                                  case inits of-                                                    []  -> return ()   -- Nothing to do-                                                    [x] -> send True $ "(assert " ++ x ++ ")"-                                                    xs  -> send True $ "(assert (and " ++ unwords xs ++ "))"---- | Upon a push, record the cut-off point for table and array restoration, if we haven't already-recordTablesAndArrayCutOff :: (MonadIO m, MonadQuery m) => m ()-recordTablesAndArrayCutOff = do st <- queryState-                                qs <- getQueryState+                            tCount <- M.size  <$> (io . readIORef) (rtblMap   st)+                            aCount <- IM.size <$> (io . readIORef) (rArrayMap st) -                                case queryTblArrPreserveIndex qs of-                                  Just _  -> return () -- already recorded, nothing to do-                                  Nothing -> do tCount <- M.size  <$> (io . readIORef) (rtblMap   st)-                                                aCount <- IM.size <$> (io . readIORef) (rArrayMap st)+                            let tInits = [ "table"  ++ show i ++ "_initializer" | i <- [0 .. tCount - 1]]+                                aInits = [ "array_" ++ show i ++ "_initializer" | i <- [0 .. aCount - 1]]+                                inits  = tInits ++ aInits -                                                modifyQueryState $ \s -> s {queryTblArrPreserveIndex = Just (tCount, aCount)}+                            case inits of+                              []  -> return ()   -- Nothing to do+                              [x] -> send True $ "(assert " ++ x ++ ")"+                              xs  -> send True $ "(assert (and " ++ unwords xs ++ "))"  -- | Generalization of 'Data.SBV.Control.inNewAssertionStack' inNewAssertionStack :: (MonadIO m, MonadQuery m) => m a -> m a@@ -524,7 +509,6 @@  | i <= 0 = error $ "Data.SBV: push requires a strictly positive level argument, received: " ++ show i  | True   = do depth <- getAssertionStackDepth                send True $ "(push " ++ show i ++ ")"-               recordTablesAndArrayCutOff                modifyQueryState $ \s -> s{queryAssertionStackDepth = depth + i}  -- | Generalization of 'Data.SBV.Control.pop'@@ -575,7 +559,10 @@ -- | Generalization of 'Data.SBV.Control.resetAssertions' resetAssertions :: (MonadIO m, MonadQuery m) => m () resetAssertions = do send True "(reset-assertions)"-                     modifyQueryState $ \s -> s{queryAssertionStackDepth = 0}+                     modifyQueryState $ \s -> s{ queryAssertionStackDepth = 0 }++                     -- Make sure we restore tables and arrays after resetAssertions: See: https://github.com/LeventErkok/sbv/issues/535+                     restoreTablesAndArrays  -- | Generalization of 'Data.SBV.Control.echo' echo :: (MonadIO m, MonadQuery m) => String -> m ()
Data/SBV/Control/Utils.hs view
@@ -10,7 +10,6 @@ -----------------------------------------------------------------------------  {-# LANGUAGE BangPatterns           #-}-{-# LANGUAGE DefaultSignatures      #-} {-# LANGUAGE FlexibleContexts       #-} {-# LANGUAGE FlexibleInstances      #-} {-# LANGUAGE FunctionalDependencies #-}@@ -26,7 +25,7 @@        io      , ask, send, getValue, getFunction, getUninterpretedValue      , getValueCV, getUIFunCVAssoc, getUnsatAssumptions-     , SMTValue(..), SMTFunction(..), registerUISMTFunction+     , SMTFunction(..), registerUISMTFunction      , getQueryState, modifyQueryState, getConfig, getObjectives, getUIs      , getSBVAssertions, getSBVPgm, getQuantifiedInputs, getObservables      , checkSat, checkSatUsing, getAllSatResult@@ -41,18 +40,13 @@      , executeQuery      ) where -import Data.Maybe (isJust) import Data.List  (sortBy, sortOn, elemIndex, partition, groupBy, tails, intercalate, nub, sort, isPrefixOf)  import Data.Char     (isPunctuation, isSpace, chr, ord, isDigit) import Data.Function (on)  import Data.Proxy-import Data.Typeable (Typeable) -import Data.Int-import Data.Word- import qualified Data.Map.Strict    as Map import qualified Data.IntMap.Strict as IMap import qualified Data.Sequence      as S@@ -66,7 +60,7 @@  import Data.Time (getZonedTime) -import Data.SBV.Core.Data     ( SV(..), trueSV, falseSV, CV(..), trueCV, falseCV, SBV, AlgReal, sbvToSV, kindOf, Kind(..)+import Data.SBV.Core.Data     ( SV(..), trueSV, falseSV, CV(..), trueCV, falseCV, SBV, sbvToSV, kindOf, Kind(..)                               , HasKind(..), mkConstCV, CVal(..), SMTResult(..)                               , NamedSymVar, SMTConfig(..), SMTModel(..)                               , QueryState(..), SVal(..), Quantifier(..), cache@@ -93,26 +87,25 @@ import Data.SBV.SMT.Utils   (showTimeoutValue, addAnnotations, alignPlain, debug, mergeSExpr, SBVException(..))  import Data.SBV.Utils.ExtractIO-import Data.SBV.Utils.Lib       (qfsToString, isKString)+import Data.SBV.Utils.Lib       (qfsToString) import Data.SBV.Utils.SExpr import Data.SBV.Utils.PrettyNum (cvToSMTLib)  import Data.SBV.Control.Types -import qualified Data.Set as Set (empty, fromList, toAscList, map)+import qualified Data.Set as Set (empty, fromList, toAscList)  import qualified Control.Exception as C  import GHC.Stack -import Unsafe.Coerce (unsafeCoerce) -- Only used safely!- -- | 'Data.SBV.Trans.Control.QueryT' as a 'SolverContext'. instance MonadIO m => SolverContext (QueryT m) where    constrain              = addQueryConstraint False []    softConstrain          = addQueryConstraint True  []    namedConstraint nm     = addQueryConstraint False [(":named", nm)]    constrainWithAttribute = addQueryConstraint False+   addAxiom               = addQueryAxiom    contextState           = queryState     setOption o@@ -133,6 +126,10 @@    where asrt | isSoft = "assert-soft"               | True   = "assert" +addQueryAxiom :: (MonadIO m, MonadQuery m) => String -> [String] -> m ()+addQueryAxiom nm ls = do send True $ "; -- user given axiom: " ++ nm+                         send True $ intercalate "\n" ls+ -- | Get the current configuration getConfig :: (MonadIO m, MonadQuery m) => m SMTConfig getConfig = queryConfig <$> getQueryState@@ -157,8 +154,8 @@ io = liftIO  -- | Sync-up the external solver with new context we have generated-syncUpSolver :: (MonadIO m, MonadQuery m) => Bool -> IncState -> m ()-syncUpSolver afterAPush is = do+syncUpSolver :: (MonadIO m, MonadQuery m) => IncState -> m ()+syncUpSolver is = do         cfg <- getConfig         ls  <- io $ do let swap  (a, b)        = (b, a)                            cmp   (a, _) (b, _) = a `compare` b@@ -172,7 +169,7 @@                        as          <- readIORef (rNewAsgns is)                        constraints <- readIORef (rNewConstraints is) -                       return $ toIncSMTLib afterAPush cfg inps ks cnsts arrs tbls uis as constraints cfg+                       return $ toIncSMTLib cfg inps ks cnsts arrs tbls uis as constraints cfg         mapM_ (send True) $ mergeSExpr ls  -- | Retrieve the query context@@ -202,21 +199,17 @@ inNewContext :: (MonadIO m, MonadQuery m) => (State -> IO a) -> m a inNewContext act = do st <- queryState                       (is, r) <- io $ withNewIncState st act-                      mbQS <- io . readIORef . rQueryState $ st-                      let afterAPush = case mbQS of-                                         Nothing -> False-                                         Just qs -> isJust (queryTblArrPreserveIndex qs)-                      syncUpSolver afterAPush is+                      syncUpSolver is                       return r  -- | Generic 'Queriable' instance for 'SymVal'/'SMTValue' values-instance (MonadIO m, SymVal a, SMTValue a) => Queriable m (SBV a) a where+instance (MonadIO m, SymVal a) => Queriable m (SBV a) a where   create  = freshVar_   project = getValue   embed   = return . literal  -- | Generic 'Queriable' instance for things that are 'Fresh' and look like containers:-instance (MonadIO m, SymVal a, SMTValue a, Foldable t, Traversable t, Fresh m (t (SBV a))) => Queriable m (t (SBV a)) (t a) where+instance (MonadIO m, SymVal a, Foldable t, Traversable t, Fresh m (t (SBV a))) => Queriable m (t (SBV a)) (t a) where   create  = fresh   project = mapM getValue   embed   = return . fmap literal@@ -338,187 +331,20 @@               loop [] --- | A class which allows for sexpr-conversion to values-class SMTValue a where-  sexprToVal :: SExpr -> Maybe a--  default sexprToVal :: Read a => SExpr -> Maybe a-  sexprToVal (ECon c) = case reads c of-                          [(v, "")] -> Just v-                          _         -> Nothing-  sexprToVal _        = Nothing---- | Integral values are easy to convert:-fromIntegralToVal :: Integral a => SExpr -> Maybe a-fromIntegralToVal (ENum (i, _)) = Just $ fromIntegral i-fromIntegralToVal _             = Nothing--instance SMTValue Int8    where sexprToVal = fromIntegralToVal-instance SMTValue Int16   where sexprToVal = fromIntegralToVal-instance SMTValue Int32   where sexprToVal = fromIntegralToVal-instance SMTValue Int64   where sexprToVal = fromIntegralToVal-instance SMTValue Word8   where sexprToVal = fromIntegralToVal-instance SMTValue Word16  where sexprToVal = fromIntegralToVal-instance SMTValue Word32  where sexprToVal = fromIntegralToVal-instance SMTValue Word64  where sexprToVal = fromIntegralToVal-instance SMTValue Integer where sexprToVal = fromIntegralToVal--instance SMTValue Float where-   sexprToVal (EFloat f)    = Just f-   sexprToVal (ENum (v, _)) = Just (fromIntegral v)-   sexprToVal _             = Nothing--instance SMTValue Double where-   sexprToVal (EDouble f)   = Just f-   sexprToVal (ENum (v, _)) = Just (fromIntegral v)-   sexprToVal _             = Nothing--instance SMTValue Bool where-   sexprToVal (ENum (1, _)) = Just True-   sexprToVal (ENum (0, _)) = Just False-   sexprToVal _             = Nothing--instance SMTValue AlgReal where-   sexprToVal (EReal a)     = Just a-   sexprToVal (ENum (v, _)) = Just (fromIntegral v)-   sexprToVal _             = Nothing--instance SMTValue Char where-   sexprToVal (ENum (i, _)) = Just (chr (fromIntegral i))-   sexprToVal _             = Nothing--instance (SMTValue a, Typeable a) => SMTValue [a] where-   -- NB. The conflation of String/[Char] forces us to have this bastard case here-   -- with unsafeCoerce to cast back to a regular string. This is unfortunate,-   -- and the ice is thin here. But it works, and is much better than a plethora-   -- of overlapping instances. Sigh.-   sexprToVal (ECon s)-    | isKString @[a] undefined && length s >= 2 && head s == '"' && last s == '"'-    = Just $ map unsafeCoerce s'-    | True-    = Just $ map (unsafeCoerce . c2w8) s'-    where s' = qfsToString (tail (init s))-          c2w8  :: Char -> Word8-          c2w8 = fromIntegral . ord--   -- Otherwise we have a good old sequence, just parse it simply:-   sexprToVal (EApp (ECon "seq.++" : rest))           = do elts <- mapM sexprToVal rest-                                                           return $ concat elts-   sexprToVal (EApp [ECon "seq.unit", a])             = do a' <- sexprToVal a-                                                           return [a']-   sexprToVal (EApp [ECon "as", ECon "seq.empty", _]) = return []--   sexprToVal _                                       = Nothing--instance (SMTValue a, SMTValue b) => SMTValue (Either a b) where-  sexprToVal (EApp [ECon "left_SBVEither",  a])                      = Left  <$> sexprToVal a-  sexprToVal (EApp [ECon "right_SBVEither", b])                      = Right <$> sexprToVal b-  sexprToVal (EApp [EApp [ECon "as", ECon "left_SBVEither",  _], a]) = Left  <$> sexprToVal a   -- CVC4 puts full ascriptions-  sexprToVal (EApp [EApp [ECon "as", ECon "right_SBVEither", _], b]) = Right <$> sexprToVal b   -- CVC4 puts full ascriptions-  sexprToVal _                                                       = Nothing--instance SMTValue a => SMTValue (Maybe a) where-  sexprToVal (ECon "nothing_SBVMaybe")                                = return Nothing-  sexprToVal (EApp [ECon "just_SBVMaybe", a])                         = Just <$> sexprToVal a-  sexprToVal (      EApp [ECon "as", ECon "nothing_SBVMaybe", _])     = return Nothing          -- Ditto here for CVC4-  sexprToVal (EApp [EApp [ECon "as", ECon "just_SBVMaybe",    _], a]) = Just <$> sexprToVal a-  sexprToVal _                                                        = Nothing--instance SMTValue () where-   sexprToVal (ECon "mkSBVTuple0") = Just ()-   sexprToVal _                    = Nothing--instance (Ord a, SymVal a) => SMTValue (RCSet a) where-   sexprToVal e = recoverKindedValue k e >>= cvt . cvVal-     where ke = kindOf (Proxy @a)-           k  = KSet ke--           cvt (CSet (RegularSet s))    = Just $ RegularSet    $ Set.map (fromCV . CV ke) s-           cvt (CSet (ComplementSet s)) = Just $ ComplementSet $ Set.map (fromCV . CV ke) s-           cvt _                        = Nothing---- | Convert a sexpr of n-tuple to constituent sexprs. Z3 and CVC4 differ here on how they--- present tuples, so we accommodate both:-sexprToTuple :: Int -> SExpr -> [SExpr]-sexprToTuple n e = try e-  where -- Z3 way-        try (EApp (ECon f : args)) = case splitAt (length "mkSBVTuple") f of-                                       ("mkSBVTuple", c) | all isDigit c && read c == n && length args == n -> args-                                       _  -> bad-        -- CVC4 way-        try  (EApp (EApp [ECon "as", ECon f, _] : args)) = try (EApp (ECon f : args))-        try  _ = bad-        bad = error $ "Data.SBV.sexprToTuple: Impossible: Expected a constructor for " ++ show n ++ " tuple, but got: " ++ show e---- 2-tuple-instance (SMTValue a, SMTValue b) => SMTValue (a, b) where-   sexprToVal s = case sexprToTuple 2 s of-                    [a, b] -> (,) <$> sexprToVal a <*> sexprToVal b-                    _      -> Nothing---- 3-tuple-instance (SMTValue a, SMTValue b, SMTValue c) => SMTValue (a, b, c) where-   sexprToVal s = case sexprToTuple 3 s of-                    [a, b, c] -> (,,) <$> sexprToVal a <*> sexprToVal b <*> sexprToVal c-                    _         -> Nothing---- 4-tuple-instance (SMTValue a, SMTValue b, SMTValue c, SMTValue d) => SMTValue (a, b, c, d) where-   sexprToVal s = case sexprToTuple 4 s of-                    [a, b, c, d] -> (,,,) <$> sexprToVal a <*> sexprToVal b <*> sexprToVal c <*> sexprToVal d-                    _            -> Nothing---- 5-tuple-instance (SMTValue a, SMTValue b, SMTValue c, SMTValue d, SMTValue e) => SMTValue (a, b, c, d, e) where-   sexprToVal s = case sexprToTuple 5 s of-                    [a, b, c, d, e] -> (,,,,) <$> sexprToVal a <*> sexprToVal b <*> sexprToVal c <*> sexprToVal d <*> sexprToVal e-                    _               -> Nothing---- 6-tuple-instance (SMTValue a, SMTValue b, SMTValue c, SMTValue d, SMTValue e, SMTValue f) => SMTValue (a, b, c, d, e, f) where-   sexprToVal s = case sexprToTuple 6 s of-                    [a, b, c, d, e, f] -> (,,,,,) <$> sexprToVal a <*> sexprToVal b <*> sexprToVal c <*> sexprToVal d <*> sexprToVal e <*> sexprToVal f-                    _                  -> Nothing---- 7-tuple-instance (SMTValue a, SMTValue b, SMTValue c, SMTValue d, SMTValue e, SMTValue f, SMTValue g) => SMTValue (a, b, c, d, e, f, g) where-   sexprToVal s = case sexprToTuple 7 s of-                    [a, b, c, d, e, f, g] -> (,,,,,,) <$> sexprToVal a <*> sexprToVal b <*> sexprToVal c <*> sexprToVal d <*> sexprToVal e <*> sexprToVal f <*> sexprToVal g-                    _                     -> Nothing---- 8-tuple-instance (SMTValue a, SMTValue b, SMTValue c, SMTValue d, SMTValue e, SMTValue f, SMTValue g, SMTValue h) => SMTValue (a, b, c, d, e, f, g, h) where-   sexprToVal s = case sexprToTuple 8 s of-                    [a, b, c, d, e, f, g, h] -> (,,,,,,,) <$> sexprToVal a <*> sexprToVal b <*> sexprToVal c <*> sexprToVal d <*> sexprToVal e <*> sexprToVal f <*> sexprToVal g <*> sexprToVal h-                    _                        -> Nothing- -- | Generalization of 'Data.SBV.Control.getValue'-getValue :: (MonadIO m, MonadQuery m, SMTValue a) => SBV a -> m a+getValue :: (MonadIO m, MonadQuery m, SymVal a) => SBV a -> m a getValue s = do sv <- inNewContext (`sbvToSV` s)-                let nm  = show sv-                    cmd = "(get-value (" ++ nm ++ "))"-                    bad = unexpected "getValue" cmd "a model value" Nothing--                r <- ask cmd--                let extract v = case sexprToVal v of-                                  Nothing -> bad r Nothing-                                  Just c  -> return c--                -- Along with regular extractions, also handle the oddball case of true/false request. These-                -- can come from queries, so we have to handle it specifically here.-                parse r bad $ \case EApp [EApp [ECon o,  v]]                   | o == show sv                                             -> extract v-                                    EApp [EApp [ENum (i, _), v@(ENum (j, _))]] | sv `elem` [falseSV, trueSV] && i `elem` [0, 1] && i == j -> extract v-                                    _                                                                                                     -> bad r Nothing+                cv <- getValueCV Nothing sv+                return $ fromCV cv  -- | A class which allows for sexpr-conversion to functions-class (HasKind r, SatModel r, SMTValue r) => SMTFunction fun a r | fun -> a r where+class (HasKind r, SatModel r) => SMTFunction fun a r | fun -> a r where   sexprToArg     :: fun -> [SExpr] -> Maybe a   smtFunName     :: (MonadIO m, SolverContext m, MonadSymbolic m) => fun -> m String   smtFunSaturate :: fun -> SBV r   smtFunType     :: fun -> SBVType   smtFunDefault  :: fun -> Maybe r-  sexprToFun     :: (MonadIO m, SolverContext m, MonadQuery m, MonadSymbolic m) => fun -> SExpr -> m (Maybe ([(a, r)], r))+  sexprToFun     :: (MonadIO m, SolverContext m, MonadQuery m, MonadSymbolic m, SymVal r) => fun -> SExpr -> m (Maybe ([(a, r)], r))    {-# MINIMAL sexprToArg, smtFunSaturate, smtFunType  #-} @@ -667,8 +493,8 @@             Just c -> SBV $ SVal k (Left c)  -- | Functions of arity 1-instance ( SymVal a, HasKind a, SMTValue a-         , SatModel r, HasKind r, SMTValue r+instance ( SymVal a, HasKind a+         , SatModel r, HasKind r          ) => SMTFunction (SBV a -> SBV r) a r          where   sexprToArg _ [a0] = sexprToVal a0@@ -679,9 +505,9 @@   smtFunSaturate f = f $ mkArg (kindOf (Proxy @a))  -- | Functions of arity 2-instance ( SymVal a,  HasKind a, SMTValue a-         , SymVal b,  HasKind b, SMTValue b-         , SatModel r, HasKind r, SMTValue r+instance ( SymVal a,  HasKind a+         , SymVal b,  HasKind b+         , SatModel r, HasKind r          ) => SMTFunction (SBV a -> SBV b -> SBV r) (a, b) r          where   sexprToArg _ [a0, a1] = (,) <$> sexprToVal a0 <*> sexprToVal a1@@ -693,10 +519,10 @@                        (mkArg (kindOf (Proxy @b)))  -- | Functions of arity 3-instance ( SymVal a,   HasKind a, SMTValue a-         , SymVal b,   HasKind b, SMTValue b-         , SymVal c,   HasKind c, SMTValue c-         , SatModel r, HasKind r, SMTValue r+instance ( SymVal a,   HasKind a+         , SymVal b,   HasKind b+         , SymVal c,   HasKind c+         , SatModel r, HasKind r          ) => SMTFunction (SBV a -> SBV b -> SBV c -> SBV r) (a, b, c) r          where   sexprToArg _ [a0, a1, a2] = (,,) <$> sexprToVal a0 <*> sexprToVal a1 <*> sexprToVal a2@@ -709,11 +535,11 @@                        (mkArg (kindOf (Proxy @c)))  -- | Functions of arity 4-instance ( SymVal a,   HasKind a, SMTValue a-         , SymVal b,   HasKind b, SMTValue b-         , SymVal c,   HasKind c, SMTValue c-         , SymVal d,   HasKind d, SMTValue d-         , SatModel r, HasKind r, SMTValue r+instance ( SymVal a,   HasKind a+         , SymVal b,   HasKind b+         , SymVal c,   HasKind c+         , SymVal d,   HasKind d+         , SatModel r, HasKind r          ) => SMTFunction (SBV a -> SBV b -> SBV c -> SBV d -> SBV r) (a, b, c, d) r          where   sexprToArg _ [a0, a1, a2, a3] = (,,,) <$> sexprToVal a0 <*> sexprToVal a1 <*> sexprToVal a2 <*> sexprToVal a3@@ -727,12 +553,12 @@                        (mkArg (kindOf (Proxy @d)))  -- | Functions of arity 5-instance ( SymVal a,   HasKind a, SMTValue a-         , SymVal b,   HasKind b, SMTValue b-         , SymVal c,   HasKind c, SMTValue c-         , SymVal d,   HasKind d, SMTValue d-         , SymVal e,   HasKind e, SMTValue e-         , SatModel r, HasKind r, SMTValue r+instance ( SymVal a,   HasKind a+         , SymVal b,   HasKind b+         , SymVal c,   HasKind c+         , SymVal d,   HasKind d+         , SymVal e,   HasKind e+         , SatModel r, HasKind r          ) => SMTFunction (SBV a -> SBV b -> SBV c -> SBV d -> SBV e -> SBV r) (a, b, c, d, e) r          where   sexprToArg _ [a0, a1, a2, a3, a4] = (,,,,) <$> sexprToVal a0 <*> sexprToVal a1 <*> sexprToVal a2 <*> sexprToVal a3 <*> sexprToVal a4@@ -747,13 +573,13 @@                        (mkArg (kindOf (Proxy @e)))  -- | Functions of arity 6-instance ( SymVal a,   HasKind a, SMTValue a-         , SymVal b,   HasKind b, SMTValue b-         , SymVal c,   HasKind c, SMTValue c-         , SymVal d,   HasKind d, SMTValue d-         , SymVal e,   HasKind e, SMTValue e-         , SymVal f,   HasKind f, SMTValue f-         , SatModel r, HasKind r, SMTValue r+instance ( SymVal a,   HasKind a+         , SymVal b,   HasKind b+         , SymVal c,   HasKind c+         , SymVal d,   HasKind d+         , SymVal e,   HasKind e+         , SymVal f,   HasKind f+         , SatModel r, HasKind r          ) => SMTFunction (SBV a -> SBV b -> SBV c -> SBV d -> SBV e -> SBV f -> SBV r) (a, b, c, d, e, f) r          where   sexprToArg _ [a0, a1, a2, a3, a4, a5] = (,,,,,) <$> sexprToVal a0 <*> sexprToVal a1 <*> sexprToVal a2 <*> sexprToVal a3 <*> sexprToVal a4 <*> sexprToVal a5@@ -769,14 +595,14 @@                        (mkArg (kindOf (Proxy @f)))  -- | Functions of arity 7-instance ( SymVal a,   HasKind a, SMTValue a-         , SymVal b,   HasKind b, SMTValue b-         , SymVal c,   HasKind c, SMTValue c-         , SymVal d,   HasKind d, SMTValue d-         , SymVal e,   HasKind e, SMTValue e-         , SymVal f,   HasKind f, SMTValue f-         , SymVal g,   HasKind g, SMTValue g-         , SatModel r, HasKind r, SMTValue r+instance ( SymVal a,   HasKind a+         , SymVal b,   HasKind b+         , SymVal c,   HasKind c+         , SymVal d,   HasKind d+         , SymVal e,   HasKind e+         , SymVal f,   HasKind f+         , SymVal g,   HasKind g+         , SatModel r, HasKind r          ) => SMTFunction (SBV a -> SBV b -> SBV c -> SBV d -> SBV e -> SBV f -> SBV g -> SBV r) (a, b, c, d, e, f, g) r          where   sexprToArg _ [a0, a1, a2, a3, a4, a5, a6] = (,,,,,,) <$> sexprToVal a0 <*> sexprToVal a1 <*> sexprToVal a2 <*> sexprToVal a3 <*> sexprToVal a4 <*> sexprToVal a5 <*> sexprToVal a6@@ -793,15 +619,15 @@                        (mkArg (kindOf (Proxy @g)))  -- | Functions of arity 8-instance ( SymVal a,   HasKind a, SMTValue a-         , SymVal b,   HasKind b, SMTValue b-         , SymVal c,   HasKind c, SMTValue c-         , SymVal d,   HasKind d, SMTValue d-         , SymVal e,   HasKind e, SMTValue e-         , SymVal f,   HasKind f, SMTValue f-         , SymVal g,   HasKind g, SMTValue g-         , SymVal h,   HasKind h, SMTValue h-         , SatModel r, HasKind r, SMTValue r+instance ( SymVal a,   HasKind a+         , SymVal b,   HasKind b+         , SymVal c,   HasKind c+         , SymVal d,   HasKind d+         , SymVal e,   HasKind e+         , SymVal f,   HasKind f+         , SymVal g,   HasKind g+         , SymVal h,   HasKind h+         , SatModel r, HasKind r          ) => SMTFunction (SBV a -> SBV b -> SBV c -> SBV d -> SBV e -> SBV f -> SBV g -> SBV h -> SBV r) (a, b, c, d, e, f, g, h) r          where   sexprToArg _ [a0, a1, a2, a3, a4, a5, a6, a7] = (,,,,,,,) <$> sexprToVal a0 <*> sexprToVal a1 <*> sexprToVal a2 <*> sexprToVal a3 <*> sexprToVal a4 <*> sexprToVal a5 <*> sexprToVal a6 <*> sexprToVal a7@@ -819,7 +645,7 @@                        (mkArg (kindOf (Proxy @h)))  -- | Generalization of 'Data.SBV.Control.getFunction'-getFunction :: (MonadIO m, MonadQuery m, SolverContext m, MonadSymbolic m, SMTFunction fun a r) => fun -> m ([(a, r)], r)+getFunction :: (MonadIO m, MonadQuery m, SolverContext m, MonadSymbolic m, SymVal a, SymVal r, SMTFunction fun a r) => fun -> m ([(a, r)], r) getFunction f = do nm <- smtFunName f                     let cmd = "(get-value (" ++ nm ++ "))"@@ -912,6 +738,10 @@         uninterp (Right [])    = Nothing                       -- I don't think this can actually happen, but just in case         uninterp (Left _)      = Nothing                       -- Out of luck, truly uninterpreted; we don't even know if it's inhabited. +-- | Go from an SExpr directly to a value+sexprToVal :: forall a. SymVal a => SExpr -> Maybe a+sexprToVal e = fromCV <$> recoverKindedValue (kindOf (Proxy @a)) e+ -- | Recover a given solver-printed value with a possible interpretation recoverKindedValue :: Kind -> SExpr -> Maybe CV recoverKindedValue k e = case k of@@ -1034,7 +864,17 @@                                                                 , "While trying to parse: " ++ show te                                                                 ] -                      args = sexprToTuple n te+                      -- | Convert a sexpr of n-tuple to constituent sexprs. Z3 and CVC4 differ here on how they+                      -- present tuples, so we accommodate both:+                      args = try te+                        where -- Z3 way+                              try (EApp (ECon f : as)) = case splitAt (length "mkSBVTuple") f of+                                                             ("mkSBVTuple", c) | all isDigit c && read c == n && length as == n -> as+                                                             _  -> bad+                              -- CVC4 way+                              try  (EApp (EApp [ECon "as", ECon f, _] : as)) = try (EApp (ECon f : as))+                              try  _ = bad+                              bad = error $ "Data.SBV.sexprToTuple: Impossible: Expected a constructor for " ++ show n ++ " tuple, but got: " ++ show te                        walk _ []           sofar = reverse sofar                       walk i (Just el:es) sofar = walk (i+1) es (cvVal el : sofar)@@ -1309,7 +1149,7 @@                                       -- Add on observables if we're asked to do so:                                       obsvs <- if grabObservables                                                   then getObservables-                                                  else do queryDebug ["*** In a quantified context, obvservables will not be printed."]+                                                  else do queryDebug ["*** In a quantified context, observables will not be printed."]                                                           return []                                        bindings <- let grab i@(ALL, _)      = return (i, Nothing)
Data/SBV/Core/AlgReals.hs view
@@ -19,6 +19,7 @@            , mkPolyReal            , algRealToSMTLib2            , algRealToHaskell+           , algRealToRational            , mergeAlgReals            , isExactRational            , algRealStructuralEqual@@ -32,6 +33,8 @@ import System.Random import Test.QuickCheck (Arbitrary(..)) +import Numeric (readSigned, readFloat)+ -- | Algebraic reals. Note that the representation is left abstract. We represent -- rational results explicitly, while the roots-of-polynomials are represented -- implicitly by their defining equation@@ -187,7 +190,34 @@ -- standard Haskell type that can represent root-of-polynomial variety. algRealToHaskell :: AlgReal -> String algRealToHaskell (AlgRational True r) = "((" ++ show r ++ ") :: Rational)"-algRealToHaskell r                    = error $ "SBV.algRealToHaskell: Unsupported argument: " ++ show r+algRealToHaskell r                    = error $ unlines [ ""+                                                        , "SBV.algRealToHaskell: Unsupported argument:"+                                                        , ""+                                                        , "   " ++ show r+                                                        , ""+                                                        , "represents an irrational number, and cannot be converted to a Haskell value."+                                                        ]++-- | Convert an 'AlgReal' to a 'Rational'. If the 'AlgReal' is exact, then you get a 'Left' value. Otherwise,+-- you get a 'Right' value which is simply an approximation.+algRealToRational :: AlgReal -> Either Rational Rational+algRealToRational a = case a of+                        AlgRational True  r        -> Left r+                        AlgRational False r        -> Left r+                        AlgPolyRoot _     Nothing  -> bad+                        AlgPolyRoot _     (Just s) -> let trimmed = case reverse s of+                                                                     '.':'.':'.':rest -> reverse rest+                                                                     _                -> s+                                                      in case readSigned readFloat trimmed of+                                                           [(v, "")] -> Right v+                                                           _         -> bad+   where bad = error $ unlines [ ""+                               , "SBV.algRealToRational: Unsupported argument:"+                               , ""+                               , "   " ++ show a+                               , ""+                               , "represents an irrational number that cannot be approximated."+                               ]  -- Try to show a rational precisely if we can, with finite number of -- digits. Otherwise, show it as a rational value.
Data/SBV/Core/Data.hs view
@@ -21,7 +21,6 @@ {-# LANGUAGE ScopedTypeVariables   #-} {-# LANGUAGE TypeApplications      #-} {-# LANGUAGE TypeFamilies          #-}-{-# LANGUAGE TypeOperators         #-}  {-# OPTIONS_GHC -Wall -Werror #-} @@ -49,7 +48,7 @@  , SBVPgm(..), Symbolic, runSymbolic, State, getPathCondition, extendPathCondition  , inSMTMode, SBVRunMode(..), Kind(..), Outputtable(..), Result(..)  , SolverContext(..), internalVariable, internalConstraint, isCodeGenMode- , SBVType(..), newUninterpreted, addAxiom+ , SBVType(..), newUninterpreted  , Quantifier(..), needsExistentials  , SMTLibPgm(..), SMTLibVersion(..), smtLibVersionExtension, smtLibReservedNames  , SolverCapabilities(..)@@ -397,6 +396,12 @@    setOption :: SMTOption -> m ()    -- | Set the logic.    setLogic :: Logic -> m ()+   -- | Add a user specified axiom to the generated SMT-Lib file. The first argument is a mere+   -- string, use for commenting purposes. The second argument is intended to hold the multiple-lines+   -- of the axiom text as expressed in SMT-Lib notation. Note that we perform no checks on the axiom+   -- itself, to see whether it's actually well-formed or is sensical by any means.+   -- A separate formalization of SMT-Lib would be very useful here.+   addAxiom :: String -> [String] -> m ()    -- | Set a solver time-out value, in milli-seconds. This function    -- essentially translates to the SMTLib call @(set-info :timeout val)@,    -- and your backend solver may or may not support it! The amount given@@ -406,7 +411,7 @@    -- | Get the state associated with this context    contextState :: m State -   {-# MINIMAL constrain, softConstrain, namedConstraint, constrainWithAttribute, setOption, contextState #-}+   {-# MINIMAL constrain, softConstrain, namedConstraint, constrainWithAttribute, setOption, addAxiom, contextState #-}     -- time-out, logic, and info are  simply options in our implementation, so default implementation suffices    setTimeOut t = setOption $ OptionKeyword ":timeout" [show t]
Data/SBV/Core/Floating.hs view
@@ -223,14 +223,14 @@   -- >>> prove $ roundTrip @Int32   -- Falsifiable. Counter-example:   --   s0 = RoundNearestTiesToEven :: RoundingMode-  --   s1 =              134280664 :: Int32+  --   s1 =             -264306721 :: Int32   --   -- Note how we get a failure on `Int32`. The counter-example value is not representable exactly as a single precision float:   ---  -- >>> toRational (134280664 :: Float)-  -- 134280672 % 1+  -- >>> toRational (-264306721 :: Float)+  -- (-264306720) % 1   ---  -- Note how the numerator is different, it is off by 8. This is hardly surprising, since floats become sparser as+  -- Note how the numerator is different, it is off by 1. This is hardly surprising, since floats become sparser as   -- the magnitude increases to be able to cover all the integer values representable.   toSFloat :: SRoundingMode -> SBV a -> SFloat @@ -263,16 +263,16 @@   -- Q.E.D.   -- >>> prove $ roundTrip @Int64   -- Falsifiable. Counter-example:-  --   s0 = RoundNearestTiesToEven :: RoundingMode-  --   s1 =    8005056270191255168 :: Int64+  --   s0 =  RoundTowardNegative :: RoundingMode+  --   s1 = -8069753317450726624 :: Int64   --   -- Just like in the `SFloat` case, once we reach 64-bits, we no longer can exactly represent the   -- integer value for all possible values:   ---  -- >>>  toRational (8005056270191255168 :: Double)-  -- 8005056270191255552 % 1+  -- >>>  toRational ( -8069753317450726624 :: Double)+  -- (-8069753317450726400) % 1   ---  -- In this case the numerator is off by 384!+  -- In this case the numerator is off by 224!   toSDouble :: SRoundingMode -> SBV a -> SDouble    -- default definition if we have an integral like
Data/SBV/Core/Model.hs view
@@ -692,11 +692,27 @@   -- | Returns (symbolic) 'sTrue' if all the elements of the given list are different.   distinct :: [a] -> SBool +  -- | Returns (symbolic) `sTrue` if all the elements of the given list are different. The second+  -- list contains exceptions, i.e., if an element belongs to that set, it will be considered+  -- distinct regardless of repetition.+  --+  -- >>> prove $ \a -> distinctExcept [a, a] [0::SInteger] .<=> a .== 0+  -- Q.E.D.+  -- >>> prove $ \a b -> distinctExcept [a, b] [0::SWord8] .<=> (a .== b .=> a .== 0)+  -- Q.E.D.+  -- >>> prove $ \a b c d -> distinctExcept [a, b, c, d] [] .== distinct [a, b, c, (d::SInteger)]+  -- Q.E.D.+  distinctExcept :: [a] -> [a] -> SBool+   -- | Returns (symbolic) 'sTrue' if all the elements of the given list are the same.   allEqual :: [a] -> SBool    -- | Symbolic membership test.   sElem    :: a -> [a] -> SBool++  -- | Symbolic negated membership test.+  sNotElem :: a -> [a] -> SBool+   {-# MINIMAL (.==) #-}    x ./=  y = sNot (x .==  y)@@ -711,8 +727,18 @@   distinct []     = sTrue   distinct (x:xs) = sAll (x ./=) xs .&& distinct xs -  sElem x xs = sAny (.== x) xs+  -- Default implementation of distinctExcept. Note that we override+  -- this method for the base types to generate better code.+  distinctExcept es ignored = go es+    where isIgnored = (`sElem` ignored) +          go []     = sTrue+          go (x:xs) = let xOK  = isIgnored x .|| sAll (\y -> isIgnored y .|| x ./= y) xs+                      in xOK .&& go xs++  x `sElem`    xs = sAny (.== x) xs+  x `sNotElem` xs = sNot (x `sElem` xs)+ -- | Symbolic Comparisons. Similar to 'Eq', we cannot implement Haskell's 'Ord' class -- since there is no way to return an 'Ordering' value from a symbolic comparison. -- Furthermore, 'OrdSymbolic' requires 'Mergeable' to implement if-then-else, for the@@ -799,6 +825,40 @@           isBool (SBV (SVal KBool _)) = True           isBool _                    = False +  -- Custom version of distinctExcept that generates better code for base types+  -- We essentially keep track of an array and count cardinalities as we walk along.+  distinctExcept []  _       = sTrue+  distinctExcept [_] _       = sTrue+  distinctExcept es  ignored+     | all isConc (es ++ ignored)+    = distinct (filter ignoreConc es)+    | True+    = SBV (SVal KBool (Right (cache r)))+    where ignoreConc x = case x `sElem` ignored of+                           SBV (SVal KBool (Left cv)) -> cvToBool cv+                           _                          -> error $ "distinctExcept: Impossible happened, concrete sElem failed: " ++ show (es, ignored, x)++          ek = case head es of  -- Head is safe here as we're guaranteed to have a non-empty es by pattern matching above. (Actually, there'll be at least two elements)+                 SBV (SVal k _) -> k++          r st = do let zero = 0 :: SInteger++                    arr <- SArray <$> newSArr st (ek, KUnbounded) (\i -> "array_" ++ show i) (Just (unSBV zero))++                    let incr x table = ite (x `sElem` ignored) zero (1 + readArray table x)++                        insert []     table = table+                        insert (x:xs) table = insert xs (writeArray table x (incr x table))++                        finalArray = insert es arr++                    sbvToSV st $ sAll (\e -> readArray finalArray e .<= 1) es++          -- Sigh, we can't use isConcrete since that requires SymVal+          -- constraint that we don't have here. (To support SBools.)+          isConc (SBV (SVal _ (Left _))) = True+          isConc _                       = False+ -- | If comparison is over something SMTLib can handle, just translate it. Otherwise desugar. instance (Ord a, SymVal a) => OrdSymbolic (SBV a) where   a@(SBV x) .<  b@(SBV y) | smtComparable "<"   a b = SBV (svLessThan x y)@@ -2263,9 +2323,17 @@    softConstrain               (SBV c) = imposeConstraint True  []               c    namedConstraint        nm   (SBV c) = imposeConstraint False [(":named", nm)] c    constrainWithAttribute atts (SBV c) = imposeConstraint False atts             c+   addAxiom                            = addSymAxiom    contextState                        = symbolicEnv     setOption o = addNewSMTOption  o++-- | Add an axiom. Only used internally, use `addAxiom` from user programs which works over+-- both regular and query modes of usage.+addSymAxiom :: (SolverContext m, MonadIO m) => String -> [String] -> m ()+addSymAxiom nm ax = do+        st <- contextState+        liftIO $ modifyState st raxioms ((nm, ax) :) (return ())  -- | Generalization of 'Data.SBV.assertWithPenalty' assertWithPenalty :: MonadSymbolic m => String -> SBool -> Penalty -> m ()
Data/SBV/Core/Sized.hs view
@@ -45,7 +45,6 @@ import Data.SBV.Core.Operations import Data.SBV.Core.Symbolic -import Data.SBV.Control.Utils import Data.SBV.SMT.SMT  -- Doctest only@@ -267,14 +266,6 @@ -- | 'SFiniteBits' instance for 'IntN' instance (KnownNat n, IsNonZero n) => SFiniteBits (IntN n) where    sFiniteBitSize _ = intOfProxy (Proxy @n)---- | Reading 'WordN' values in queries.-instance (KnownNat n, IsNonZero n) => SMTValue (WordN n) where-   sexprToVal e = WordN <$> sexprToVal e---- | Reading 'IntN' values in queries.-instance (KnownNat n, IsNonZero n) => SMTValue (IntN n) where-   sexprToVal e = IntN <$> sexprToVal e  -- | Constructing models for 'WordN' instance (KnownNat n, IsNonZero n) => SatModel (WordN n) where
Data/SBV/Core/Symbolic.hs view
@@ -33,7 +33,7 @@   , Op(..), PBOp(..), OvOp(..), FPOp(..), StrOp(..), SeqOp(..), SetOp(..), RegExp(..)   , Quantifier(..), needsExistentials   , RoundingMode(..)-  , SBVType(..), svUninterpreted, newUninterpreted, addAxiom+  , SBVType(..), svUninterpreted, newUninterpreted   , SVal(..)   , svMkSymVar, sWordN, sWordN_, sIntN, sIntN_   , ArrayContext(..), ArrayInfo@@ -577,7 +577,6 @@                              , queryTerminate           :: IO ()                              , queryTimeOutValue        :: Maybe Int                              , queryAssertionStackDepth :: Int-                             , queryTblArrPreserveIndex :: Maybe (Int, Int)                              }  -- | Computations which support query operations.@@ -1391,9 +1390,9 @@                                                            , "Only existential variables are supported in query mode."                                                            ]                    if isTracker-                      then modifyState st rinps (second ((:) (sv, nm)) *** Set.insert nm)+                      then modifyState st rinps (second ((sv, nm) :) *** Set.insert nm)                                      $ noInteractive ["Adding a new tracker variable in interactive mode: " ++ show nm]-                      else modifyState st rinps (first ((:) (q, (sv, nm))) *** Set.insert nm)+                      else modifyState st rinps (first ((q, (sv, nm)) :) *** Set.insert nm)                                      $ modifyIncState st rNewInps newInp                    return $ SVal k $ Right $ cache (const (return sv)) @@ -1401,16 +1400,6 @@          -- Also, the following will fail if we span the range of integers without finding a match, but your computer would          -- die way ahead of that happening if that's the case!          mkUnique prefix names = head $ dropWhile (`Set.member` names) (prefix : [prefix ++ "_" ++ show i | i <- [(0::Int)..]])---- | Generalization of 'Data.SBV.addAxiom'-addAxiom :: MonadSymbolic m => String -> [String] -> m ()-addAxiom nm ax = do-        st <- symbolicEnv-        liftIO $ modifyState st raxioms ((nm, ax) :)-                           $ noInteractive [ "Adding a new axiom:"-                                           , "  Named: " ++ show nm-                                           , "  Axiom: " ++ unlines ax-                                           ]  -- | Generalization of 'Data.SBV.runSymbolic' runSymbolic :: MonadIO m => SBVRunMode -> SymbolicT m a -> m (a, Result)
Data/SBV/Dynamic.hs view
@@ -81,6 +81,9 @@   , safeWith   -- * Proving properties using multiple solvers   , proveWithAll, proveWithAny, satWithAll, satWithAny+  -- * Proving properties using multiple threads+  , proveConcurrentWithAll, proveConcurrentWithAny+  , satConcurrentWithAny, satConcurrentWithAll   -- * Quick-check   , svQuickCheck @@ -146,7 +149,10 @@ import Data.SBV.SMT.SMT        (ThmResult(..), SatResult(..), SafeResult(..), OptimizeResult(..), AllSatResult(..), genParse) import Data.SBV                (sbvCheckSolverInstallation, defaultSolverConfig, sbvAvailableSolvers) -import qualified Data.SBV                as SBV (SBool, proveWithAll, proveWithAny, satWithAll, satWithAny)+import qualified Data.SBV                as SBV (SBool, proveWithAll, proveWithAny, satWithAll, satWithAny+                                                , proveConcurrentWithAll, proveConcurrentWithAny+                                                , satConcurrentWithAny, satConcurrentWithAll+                                                ) import qualified Data.SBV.Core.Data      as SBV (SBV(..)) import qualified Data.SBV.Core.Model     as SBV (sbvQuickCheck) import qualified Data.SBV.Provers.Prover as SBV (proveWith, satWith, safeWith, allSatWith, generateSMTBenchmark)@@ -194,6 +200,20 @@ proveWithAny :: [SMTConfig] -> Symbolic SVal -> IO (Solver, NominalDiffTime, ThmResult) proveWithAny cfgs s = SBV.proveWithAny cfgs (fmap toSBool s) +-- | Prove a property with query mode using multiple threads. Each query+-- computation will spawn a thread and a unique instance of your solver to run+-- asynchronously. The 'Symbolic' 'SVal' is duplicated for each thread. This+-- function will block until all child threads return.+proveConcurrentWithAll :: SMTConfig -> Symbolic SVal -> [Query SVal] -> IO [(Solver, NominalDiffTime, ThmResult)]+proveConcurrentWithAll cfg s queries = SBV.proveConcurrentWithAll cfg queries (fmap toSBool s)++-- | Prove a property with query mode using multiple threads. Each query+-- computation will spawn a thread and a unique instance of your solver to run+-- asynchronously. The 'Symbolic' 'SVal' is duplicated for each thread. This+-- function will return the first query computation that completes, killing the others.+proveConcurrentWithAny :: SMTConfig -> Symbolic SVal -> [Query SVal] -> IO (Solver, NominalDiffTime, ThmResult)+proveConcurrentWithAny cfg s queries = SBV.proveConcurrentWithAny cfg queries (fmap toSBool s)+ -- | Find a satisfying assignment to a property with multiple solvers, -- running them in separate threads. The results will be returned in -- the order produced.@@ -205,6 +225,20 @@ -- to finish will be returned, remaining threads will be killed. satWithAny :: [SMTConfig] -> Symbolic SVal -> IO (Solver, NominalDiffTime, SatResult) satWithAny cfgs s = SBV.satWithAny cfgs (fmap toSBool s)++-- | Find a satisfying assignment to a property with multiple threads in query+-- mode. The 'Symbolic' 'SVal' represents what is known to all child query threads.+-- Each query thread will spawn a unique instance of the solver. Only the first+-- one to finish will be returned and the other threads will be killed.+satConcurrentWithAny :: SMTConfig -> [Query b] -> Symbolic SVal -> IO (Solver, NominalDiffTime, SatResult)+satConcurrentWithAny cfg qs s = SBV.satConcurrentWithAny cfg qs (fmap toSBool s)++-- | Find a satisfying assignment to a property with multiple threads in query+-- mode. The 'Symbolic' 'SVal' represents what is known to all child query threads.+-- Each query thread will spawn a unique instance of the solver. This function+-- will block until all child threads have completed.+satConcurrentWithAll :: SMTConfig -> [Query b] -> Symbolic SVal -> IO [(Solver, NominalDiffTime, SatResult)]+satConcurrentWithAll cfg qs s = SBV.satConcurrentWithAll cfg qs (fmap toSBool s)  -- | Extract a model, the result is a tuple where the first argument (if True) -- indicates whether the model was "probable". (i.e., if the solver returned unknown.)
Data/SBV/Either.hs view
@@ -13,7 +13,6 @@ {-# LANGUAGE Rank2Types          #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TypeApplications    #-}-{-# LANGUAGE TypeOperators       #-}  {-# OPTIONS_GHC -Wall -Werror #-}
Data/SBV/List.hs view
@@ -130,7 +130,7 @@ -- Q.E.D. -- >>> sat $ \(l :: SList Word16) -> length l .>= 2 .&& listToListAt l 0 ./= listToListAt l (length l - 1) -- Satisfiable. Model:---   s0 = [0,0,256] :: [Word16]+--   s0 = [0,0,8] :: [Word16] listToListAt :: SymVal a => SList a -> SInteger -> SList a listToListAt s offset = subList s offset 1 @@ -139,7 +139,8 @@ -- -- >>> prove $ \i -> i `inRange` (0, 4) .=> [1,1,1,1,1] `elemAt` i .== (1::SInteger) -- Q.E.D.--- >>> prove $ \(l :: SList Integer) i e -> i `inRange` (0, length l - 1) .&& l `elemAt` i .== e .=> indexOf l (singleton e) .<= i+--+-- ->>> prove $ \(l :: SList Integer) i e -> i `inRange` (0, length l - 1) .&& l `elemAt` i .== e .=> indexOf l (singleton e) .<= i -- Q.E.D. elemAt :: forall a. SymVal a => SList a -> SInteger -> SBV a elemAt l i@@ -315,8 +316,9 @@ -- | @`indexOf` l sub@. Retrieves first position of @sub@ in @l@, @-1@ if there are no occurrences. -- Equivalent to @`offsetIndexOf` l sub 0@. ----- >>> prove $ \(l :: SList Int8) i -> i .> 0 .&& i .< length l .=> indexOf l (subList l i 1) .<= i+-- ->>> prove $ \(l :: SList Int8) i -> i .> 0 .&& i .< length l .=> indexOf l (subList l i 1) .<= i -- Q.E.D.+-- -- >>> prove $ \(l1 :: SList Word16) l2 -> length l2 .> length l1 .=> indexOf l1 l2 .== -1 -- Q.E.D. indexOf :: (Eq a, SymVal a) => SList a -> SList a -> SInteger
Data/SBV/Maybe.hs view
@@ -13,7 +13,6 @@ {-# LANGUAGE Rank2Types          #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TypeApplications    #-}-{-# LANGUAGE TypeOperators       #-}  {-# OPTIONS_GHC -Wall -Werror #-}
Data/SBV/Provers/CVC4.hs view
@@ -28,7 +28,7 @@            name         = CVC4          , executable   = "cvc4"          , preprocess   = clean-         , options      = const ["--lang", "smt", "--incremental", "--interactive", "--no-interactive-prompt"]+         , options      = const ["--lang", "smt", "--incremental", "--interactive", "--no-interactive-prompt", "--model-witness-value"]          , engine       = standardEngine "SBV_CVC4" "SBV_CVC4_OPTIONS"          , capabilities = SolverCapabilities {                                 supportsQuantifiers        = True
Data/SBV/Provers/MathSAT.hs view
@@ -41,7 +41,7 @@                               , supportsOptimization       = False                               , supportsPseudoBooleans     = False                               , supportsCustomQueries      = True-                              , supportsGlobalDecls        = False+                              , supportsGlobalDecls        = True                               , supportsDataTypes          = True                               , supportsFlattenedModels    = Nothing                               }
Data/SBV/Provers/Prover.hs view
@@ -23,6 +23,7 @@ module Data.SBV.Provers.Prover (          SMTSolver(..), SMTConfig(..), Predicate        , MProvable(..), Provable, proveWithAll, proveWithAny , satWithAll, satWithAny+       , satConcurrentWithAny, satConcurrentWithAll, proveConcurrentWithAny, proveConcurrentWithAll        , generateSMTBenchmark        , Goal        , ThmResult(..), SatResult(..), AllSatResult(..), SafeResult(..), OptimizeResult(..), SMTResult(..)@@ -38,8 +39,9 @@ import Control.Monad.IO.Class (MonadIO, liftIO) import Control.DeepSeq        (rnf, NFData(..)) -import Control.Concurrent.Async (async, waitAny, asyncThreadId, Async)-import Control.Exception (finally, throwTo, AsyncException(ThreadKilled))+import Control.Concurrent.Async (async, waitAny, asyncThreadId, Async, mapConcurrently)+import Control.Exception (finally, throwTo)+import System.Exit (ExitCode(ExitSuccess))  import System.IO.Unsafe (unsafeInterleaveIO)             -- only used safely! @@ -505,7 +507,7 @@  -- | Prove a property with multiple solvers, running them in separate threads. Only -- the result of the first one to finish will be returned, remaining threads will be killed.--- Note that we send a @ThreadKilled@ to the losing processes, but we do *not* actually wait for them+-- Note that we send an exception to the losing processes, but we do *not* actually wait for them -- to finish. In rare cases this can lead to zombie processes. In previous experiments, we found -- that some processes take their time to terminate. So, this solution favors quick turnaround. proveWithAny :: Provable a => [SMTConfig] -> a -> IO (Solver, NominalDiffTime, ThmResult)@@ -518,12 +520,46 @@  -- | Find a satisfying assignment to a property with multiple solvers, running them in separate threads. Only -- the result of the first one to finish will be returned, remaining threads will be killed.--- Note that we send a @ThreadKilled@ to the losing processes, but we do *not* actually wait for them+-- Note that we send an exception to the losing processes, but we do *not* actually wait for them -- to finish. In rare cases this can lead to zombie processes. In previous experiments, we found -- that some processes take their time to terminate. So, this solution favors quick turnaround. satWithAny :: Provable a => [SMTConfig] -> a -> IO (Solver, NominalDiffTime, SatResult)-satWithAny    = (`sbvWithAny` satWith)+satWithAny = (`sbvWithAny` satWith) +-- | Find a satisfying assignment to a property using a single solver, but+-- providing several query problems of interest, with each query running in a+-- separate thread and return the first one that returns. This can be useful to+-- use symbolic mode to drive to a location in the search space of the solver+-- and then refine the problem in query mode. If the computation is very hard to+-- solve for the solver than running in concurrent mode may provide a large+-- performance benefit.+satConcurrentWithAny :: Provable a => SMTConfig -> [Query b] -> a -> IO (Solver, NominalDiffTime, SatResult)+satConcurrentWithAny solver qs a = do (slvr,time,result) <- sbvConcurrentWithAny solver go qs a+                                      return (slvr, time, SatResult result)+  where go cfg a' q = runWithQuery True (do _ <- q; checkNoOptimizations >> Control.getSMTResult) cfg a'++-- | Prove a property by running many queries each isolated to their own thread+-- concurrently and return the first that finishes, killing the others+proveConcurrentWithAny :: Provable a => SMTConfig -> [Query b] -> a -> IO (Solver, NominalDiffTime, ThmResult)+proveConcurrentWithAny solver qs a = do (slvr,time,result) <- sbvConcurrentWithAny solver go qs a+                                        return (slvr, time, ThmResult result)+  where go cfg a' q = runWithQuery False (do _ <- q;  checkNoOptimizations >> Control.getSMTResult) cfg a'++-- | Find a satisfying assignment to a property using a single solver, but run+-- each query problem in a separate isolated thread and wait for each thread to+-- finish. See 'satConcurrentWithAny' for more details.+satConcurrentWithAll :: Provable a => SMTConfig -> [Query b] -> a -> IO [(Solver, NominalDiffTime, SatResult)]+satConcurrentWithAll solver qs a = do results <- sbvConcurrentWithAll solver go qs a+                                      return $ (\(a',b,c) -> (a',b,SatResult c)) <$> results+  where go cfg a' q = runWithQuery True (do _ <- q; checkNoOptimizations >> Control.getSMTResult) cfg a'++-- | Prove a property by running many queries each isolated to their own thread+-- concurrently and wait for each to finish returning all results+proveConcurrentWithAll :: Provable a => SMTConfig -> [Query b] -> a -> IO [(Solver, NominalDiffTime, ThmResult)]+proveConcurrentWithAll solver qs a = do results <- sbvConcurrentWithAll solver go qs a+                                        return $ (\(a',b,c) -> (a',b,ThmResult c)) <$> results+  where go cfg a' q = runWithQuery False (do _ <- q; checkNoOptimizations >> Control.getSMTResult) cfg a'+ -- | Create an SMT-Lib2 benchmark. The 'Bool' argument controls whether this is a SAT instance, i.e., -- translate the query directly, or a PROVE instance, i.e., translate the negated query. generateSMTBenchmark :: (MonadIO m, MProvable m a) => Bool -> a -> m String@@ -701,7 +737,33 @@    where -- Async's `waitAnyCancel` nicely blocks; so we use this variant to ignore the          -- wait part for killed threads.          waitAnyFastCancel asyncs = waitAny asyncs `finally` mapM_ cancelFast asyncs-         cancelFast other = throwTo (asyncThreadId other) ThreadKilled+         cancelFast other = throwTo (asyncThreadId other) ExitSuccess+++sbvConcurrentWithAny :: NFData c => SMTConfig -> (SMTConfig -> a -> QueryT m b -> IO c) -> [QueryT m b] -> a -> IO (Solver, NominalDiffTime, c)+sbvConcurrentWithAny solver what queries a = snd `fmap` (mapM runQueryInThread queries >>= waitAnyFastCancel)+  where  -- Async's `waitAnyCancel` nicely blocks; so we use this variant to ignore the+         -- wait part for killed threads.+         waitAnyFastCancel asyncs = waitAny asyncs `finally` mapM_ cancelFast asyncs+         cancelFast other = throwTo (asyncThreadId other) ExitSuccess+         runQueryInThread q = do beginTime <- getCurrentTime+                                 runInThread beginTime (\cfg -> what cfg a q) solver+++sbvConcurrentWithAll :: NFData c => SMTConfig -> (SMTConfig -> a -> QueryT m b -> IO c) -> [QueryT m b] -> a -> IO [(Solver, NominalDiffTime, c)]+sbvConcurrentWithAll solver what queries a = mapConcurrently runQueryInThread queries  >>= unsafeInterleaveIO . go+  where  runQueryInThread q = do beginTime <- getCurrentTime+                                 runInThread beginTime (\cfg -> what cfg a q) solver++         go []  = return []+         go as  = do (d, r) <- waitAny as+                     -- The following filter works because the Eq instance on Async+                     -- checks the thread-id; so we know that we're removing the+                     -- correct solver from the list. This also allows for+                     -- running the same-solver (with different options), since+                     -- they will get different thread-ids.+                     rs <- unsafeInterleaveIO $ go (filter (/= d) as)+                     return (r : rs)  -- | Perform action for all given configs, return all the results. sbvWithAll :: NFData b => [SMTConfig] -> (SMTConfig -> a -> IO b) -> a -> IO [(Solver, NominalDiffTime, b)]
Data/SBV/SMT/SMT.hs view
@@ -45,7 +45,7 @@ import Data.Char          (isSpace) import Data.Maybe         (fromMaybe, isJust) import Data.Int           (Int8, Int16, Int32, Int64)-import Data.List          (intercalate, isPrefixOf, transpose)+import Data.List          (intercalate, isPrefixOf, transpose, isInfixOf) import Data.Word          (Word8, Word16, Word32, Word64)  import Data.IORef (readIORef, writeIORef)@@ -711,7 +711,15 @@                                                                                              , sbvExceptionExitCode    = Nothing                                                                                              , sbvExceptionConfig      = cfg { solver = (solver cfg) { executable = execPath } }                                                                                              , sbvExceptionReason      = Nothing-                                                                                             , sbvExceptionHint        = Nothing+                                                                                             , sbvExceptionHint        = if "hGetLine: end of file" `isInfixOf` e+                                                                                                                         then Just [ "Solver process prematurely ended communication."+                                                                                                                                   , ""+                                                                                                                                   , "It is likely it was terminated because of a seg-fault."+                                                                                                                                   , "Run with 'transcript=Just \"bad.smt2\"' option, and feed"+                                                                                                                                   , "the generated \"bad.smt2\" file directly to the solver"+                                                                                                                                   , "outside of SBV for further information."+                                                                                                                                   ]+                                                                                                                         else Nothing                                                                                              }                                                SolverTimeout e -> do terminateProcess pid -- NB. Do not *wait* for the process, just quit.@@ -872,7 +880,6 @@                                                  , queryTerminate           = cleanUp                                                  , queryTimeOutValue        = Nothing                                                  , queryAssertionStackDepth = 0-                                                 , queryTblArrPreserveIndex = Nothing                                                  }                                  qsp = rQueryState ctx
Data/SBV/SMT/SMTLib.hs view
@@ -32,9 +32,9 @@                                       SMTLib2 -> toSMTLib2  -- | Convert to SMT-Lib, in an incremental query context.-toIncSMTLib :: Bool -> SMTConfig -> SMTLibIncConverter [String]-toIncSMTLib afterAPush SMTConfig{smtLibVersion} = case smtLibVersion of-                                                     SMTLib2 -> toIncSMTLib2 afterAPush+toIncSMTLib :: SMTConfig -> SMTLibIncConverter [String]+toIncSMTLib SMTConfig{smtLibVersion} = case smtLibVersion of+                                         SMTLib2 -> toIncSMTLib2  -- | Convert to SMTLib-2 format toSMTLib2 :: SMTLibConverter SMTLibPgm@@ -69,6 +69,6 @@                  where quantifiers = map fst (fst qinps)  -- | Convert to SMTLib-2 format-toIncSMTLib2 :: Bool -> SMTLibIncConverter [String]+toIncSMTLib2 :: SMTLibIncConverter [String] toIncSMTLib2 = cvt SMTLib2   where cvt SMTLib2 = SMT2.cvtInc
Data/SBV/SMT/SMTLib2.hs view
@@ -166,7 +166,7 @@              ++ [ "; --- optimization tracker variables ---" | not (null trackerVars) ]              ++ [ "(declare-fun " ++ show s ++ " " ++ svFunType [] s ++ ") ; tracks " ++ nm | (s, nm) <- trackerVars]              ++ [ "; --- constant tables ---" ]-             ++ concatMap (constTable False) constTables+             ++ concatMap constTable constTables              ++ [ "; --- skolemized tables ---" ]              ++ map (skolemTable (unwords (map svType foralls))) skolemTables              ++ [ "; --- arrays ---" ]@@ -212,7 +212,7 @@          (constTables, skolemTables) = ([(t, d) | (t, Left d) <- allTables], [(t, d) | (t, Right d) <- allTables])         allTables = [(t, genTableData rm skolemMap (not (null foralls), forallArgs) (map fst consts) t) | t <- tbls]-        (arrayConstants, arrayDelayeds, arraySetups) = unzip3 $ map (declArray cfg False (not (null foralls)) consts skolemMap) arrs+        (arrayConstants, arrayDelayeds, arraySetups) = unzip3 $ map (declArray cfg (not (null foralls)) consts skolemMap) arrs         delayedEqualities = concatMap snd skolemTables          delayedAsserts []              = []@@ -384,8 +384,8 @@ -- to do as an extra in the incremental context. See `Data.SBV.Core.Symbolic.registerKind` -- for a list of what we include, in case something doesn't show up -- and you need it!-cvtInc :: Bool -> SMTLibIncConverter [String]-cvtInc afterAPush inps newKs consts arrs tbls uis (SBVPgm asgnsSeq) cstrs cfg =+cvtInc :: SMTLibIncConverter [String]+cvtInc inps newKs consts arrs tbls uis (SBVPgm asgnsSeq) cstrs cfg =             -- any new settings?                settings             -- sorts@@ -404,7 +404,7 @@             -- uninterpreteds             ++ concatMap declUI uis             -- tables-            ++ concatMap (constTable afterAPush) allTables+            ++ concatMap constTable allTables             -- expressions             ++ map  (declDef cfg skolemMap tableMap) (F.toList asgnsSeq)             -- delayed equalities@@ -423,7 +423,7 @@          declInp (s, _) = "(declare-fun " ++ show s ++ " () " ++ svType s ++ ")" -        (arrayConstants, arrayDelayeds, arraySetups) = unzip3 $ map (declArray cfg afterAPush False consts skolemMap) arrs+        (arrayConstants, arrayDelayeds, arraySetups) = unzip3 $ map (declArray cfg False consts skolemMap) arrs          allTables = [(t, either id id (genTableData rm skolemMap (False, []) (map fst consts) t)) | t <- tbls]         tableMap  = IM.fromList $ map mkTable allTables@@ -465,20 +465,20 @@ declAx :: (String, [String]) -> String declAx (nm, ls) = (";; -- user given axiom: " ++ nm ++ "\n") ++ intercalate "\n" ls -constTable :: Bool -> (((Int, Kind, Kind), [SV]), [String]) -> [String]-constTable afterAPush (((i, ak, rk), _elts), is) = decl : zipWith wrap [(0::Int)..] is ++ setup+constTable :: (((Int, Kind, Kind), [SV]), [String]) -> [String]+constTable (((i, ak, rk), _elts), is) = decl : zipWith wrap [(0::Int)..] is ++ setup   where t       = "table" ++ show i         decl    = "(declare-fun " ++ t ++ " (" ++ smtType ak ++ ") " ++ smtType rk ++ ")"          -- Arrange for initializers         mkInit idx   = "table" ++ show i ++ "_initializer_" ++ show (idx :: Int)         initializer  = "table" ++ show i ++ "_initializer"-        wrap index s-          | afterAPush = "(define-fun " ++ mkInit index ++ " () Bool " ++ s ++ ")"-          | True       = "(assert " ++ s ++ ")"-        lis          = length is++        wrap index s = "(define-fun " ++ mkInit index ++ " () Bool " ++ s ++ ")"++        lis  = length is+         setup-          | not afterAPush = []           | lis == 0       = [ "(define-fun " ++ initializer ++ " () Bool true) ; no initializiation needed"                              ]           | lis == 1       = [ "(define-fun " ++ initializer ++ " () Bool " ++ mkInit 0 ++ ")"@@ -488,7 +488,6 @@                              , "(assert " ++ initializer ++ ")"                              ] - skolemTable :: String -> (((Int, Kind, Kind), [SV]), [String]) -> String skolemTable qsIn (((i, ak, rk), _elts), _) = decl   where qs   = if null qsIn then "" else qsIn ++ " "@@ -517,8 +516,8 @@ -- we might have to skolemize those. Implement this properly. -- The difficulty is with the Mutate/Merge: We have to postpone an init if -- the components are themselves postponed, so this cannot be implemented as a simple map.-declArray :: SMTConfig -> Bool -> Bool -> [(SV, CV)] -> SkolemMap -> (Int, ArrayInfo) -> ([String], [String], [String])-declArray cfg afterAPush quantified consts skolemMap (i, (_, (aKnd, bKnd), ctx)) = (adecl : zipWith wrap [(0::Int)..] (map snd pre), zipWith wrap [lpre..] (map snd post), setup)+declArray :: SMTConfig -> Bool -> [(SV, CV)] -> SkolemMap -> (Int, ArrayInfo) -> ([String], [String], [String])+declArray cfg quantified consts skolemMap (i, (_, (aKnd, bKnd), ctx)) = (adecl : zipWith wrap [(0::Int)..] (map snd pre), zipWith wrap [lpre..] (map snd post), setup)   where constNames = map fst consts         topLevel = not quantified || case ctx of                                        ArrayFree mbi      -> maybe True (`elem` constNames) mbi@@ -554,17 +553,13 @@         mkInit idx    = "array_" ++ show i ++ "_initializer_" ++ show (idx :: Int)         initializer   = "array_" ++ show i ++ "_initializer" -        wrap index s-          | afterAPush = "(define-fun " ++ mkInit index ++ " () Bool " ++ s ++ ")"-          | True       = "(assert " ++ s ++ ")"+        wrap index s = "(define-fun " ++ mkInit index ++ " () Bool " ++ s ++ ")"          lpre          = length pre         lAll          = lpre + length post          setup-          | not afterAPush = []-          | lAll == 0      = [ "(define-fun " ++ initializer ++ " () Bool true) ; no initializiation needed"-                             ]+          | lAll == 0      = [ "(define-fun " ++ initializer ++ " () Bool true) ; no initializiation needed" | not quantified]           | lAll == 1      = [ "(define-fun " ++ initializer ++ " () Bool " ++ mkInit 0 ++ ")"                              , "(assert " ++ initializer ++ ")"                              ]
Data/SBV/Set.hs view
@@ -308,13 +308,13 @@ -- >>> sat $ \i -> hasSize (full :: SSet Integer) i -- Unsatisfiable ----- >>> prove $ \a b i j k -> hasSize (a :: SSet Integer) i .&& hasSize (b :: SSet Integer) j .&& hasSize (a `union` b) k .=> k .>= i `smax` j+-- ->>> prove $ \a b i j k -> hasSize (a :: SSet Integer) i .&& hasSize (b :: SSet Integer) j .&& hasSize (a `union` b) k .=> k .>= i `smax` j -- Q.E.D. ----- >>> prove $ \a b i j k -> hasSize (a :: SSet Integer) i .&& hasSize (b :: SSet Integer) j .&& hasSize (a `intersection` b) k .=> k .<= i `smin` j+-- ->>> prove $ \a b i j k -> hasSize (a :: SSet Integer) i .&& hasSize (b :: SSet Integer) j .&& hasSize (a `intersection` b) k .=> k .<= i `smin` j -- Q.E.D. ----- >>> prove $ \a k -> hasSize (a :: SSet Integer) k .=> k .>= 0+-- ->>> prove $ \a k -> hasSize (a :: SSet Integer) k .=> k .>= 0 -- Q.E.D. hasSize :: (Ord a, SymVal a) => SSet a -> SInteger -> SBool hasSize sa si
Data/SBV/String.hs view
@@ -133,7 +133,7 @@ -- Q.E.D. -- >>> sat $ \s -> length s .>= 2 .&& strToStrAt s 0 ./= strToStrAt s (length s - 1) -- Satisfiable. Model:---   s0 = "\NUL\NUL\DLE" :: String+--   s0 = "\NUL\NUL\EOT" :: String strToStrAt :: SString -> SInteger -> SString strToStrAt s offset = subStr s offset 1 @@ -142,7 +142,8 @@ -- -- >>> prove $ \i -> i .>= 0 .&& i .<= 4 .=> "AAAAA" `strToCharAt` i .== literal 'A' -- Q.E.D.--- >>> prove $ \s i c -> i `inRange` (0, length s - 1) .&& s `strToCharAt` i .== c .=> indexOf s (singleton c) .<= i+--+-- ->>> prove $ \s i c -> i `inRange` (0, length s - 1) .&& s `strToCharAt` i .== c .=> indexOf s (singleton c) .<= i -- Q.E.D. strToCharAt :: SString -> SInteger -> SChar strToCharAt s i@@ -310,8 +311,9 @@ -- | @`indexOf` s sub@. Retrieves first position of @sub@ in @s@, @-1@ if there are no occurrences. -- Equivalent to @`offsetIndexOf` s sub 0@. ----- >>> prove $ \s i -> i .> 0 .&& i .< length s .=> indexOf s (subStr s i 1) .<= i+-- ->>> prove $ \s i -> i .> 0 .&& i .< length s .=> indexOf s (subStr s i 1) .<= i -- Q.E.D.+-- -- >>> prove $ \s1 s2 -> length s2 .> length s1 .=> indexOf s1 s2 .== -1 -- Q.E.D. indexOf :: SString -> SString -> SInteger@@ -341,7 +343,6 @@ -- | @`strToNat` s@. Retrieve integer encoded by string @s@ (ground rewriting only). -- Note that by definition this function only works when @s@ only contains digits, -- that is, if it encodes a natural number. Otherwise, it returns '-1'.--- See <http://cvc4.cs.stanford.edu/wiki/Strings> for details. -- -- >>> prove $ \s -> let n = strToNat s in length s .== 1 .=> (-1) .<= n .&& n .<= 9 -- Q.E.D.@@ -357,7 +358,6 @@ -- | @`natToStr` i@. Retrieve string encoded by integer @i@ (ground rewriting only). -- Again, only naturals are supported, any input that is not a natural number -- produces empty string, even though we take an integer as an argument.--- See <http://cvc4.cs.stanford.edu/wiki/Strings> for details. -- -- >>> prove $ \i -> length (natToStr i) .== 3 .=> i .<= 999 -- Q.E.D.
Data/SBV/Tools/BoundedList.hs view
@@ -145,3 +145,6 @@ -- | Bounded insertion sort bsort :: (Ord a, SymVal a) => Int -> SList a -> SList a bsort cnt = bfoldr cnt (binsert cnt) []++-- Hlint is thinking "OverloadedLists" is wrong, but GHC wants it.+{-# ANN module ("HLint: ignore Unused LANGUAGE pragma" :: String) #-}
Data/SBV/Tools/Polynomial.hs view
@@ -14,7 +14,6 @@ {-# LANGUAGE FlexibleInstances    #-} {-# LANGUAGE PatternGuards        #-} {-# LANGUAGE TypeFamilies         #-}-{-# LANGUAGE TypeOperators        #-} {-# LANGUAGE UndecidableInstances #-}  {-# OPTIONS_GHC -Wall -Werror #-}
Data/SBV/Tools/Range.hs view
@@ -87,11 +87,13 @@ -- [(0.0,oo)] -- >>> ranges $ \x -> x .< (0::SReal) -- [(-oo,0.0)]-ranges :: forall a. (Ord a, Num a, SymVal a,  SMTValue a, SatModel a, Metric a, SymVal (MetricSpace a), SatModel (MetricSpace a)) => (SBV a -> SBool) -> IO [Range a]+-- >>> ranges $ \(x :: SWord8) -> 2*x .== 4+-- [[2,3),(129,130]]+ranges :: forall a. (Ord a, Num a, SymVal a,  SatModel a, Metric a, SymVal (MetricSpace a), SatModel (MetricSpace a)) => (SBV a -> SBool) -> IO [Range a] ranges = rangesWith defaultSMTCfg  -- | Compute ranges, using the given solver configuration.-rangesWith :: forall a. (Ord a, Num a, SymVal a,  SMTValue a, SatModel a, Metric a, SymVal (MetricSpace a), SatModel (MetricSpace a)) => SMTConfig -> (SBV a -> SBool) -> IO [Range a]+rangesWith :: forall a. (Ord a, Num a, SymVal a,  SatModel a, Metric a, SymVal (MetricSpace a), SatModel (MetricSpace a)) => SMTConfig -> (SBV a -> SBool) -> IO [Range a] rangesWith cfg prop = do mbBounds <- getInitialBounds                          case mbBounds of                            Nothing -> return []@@ -135,45 +137,68 @@                                                                     Just r  -> r                                  _                             -> error $ "Data.SBV.ranges.getRegVal: Cannot parse " ++ show cv -            IndependentResult m <- optimizeWith cfg Independent $ do x <- free_-                                                                     constrain $ prop x-                                                                     minimize "min" x-                                                                     maximize "max" x-            case head (map snd m) of-              Unsatisfiable{} -> return Nothing-              Unknown{}       -> error "Solver said Unknown!"-              ProofError{}    -> error (show (IndependentResult m))-              _               -> let Just (Just mi) = getModelObjectiveValue "min" `fmap` ("min" `lookup` m)-                                     Just (Just ma) = getModelObjectiveValue "max" `fmap` ("max" `lookup` m)-                                 in return $ Just $ Range (getGenVal mi) (getGenVal ma) +                getBound cstr = do let objName = "boundValue"+                                   res@(LexicographicResult m) <- optimizeWith cfg Lexicographic $ do x <- free_+                                                                                                      constrain $ prop x+                                                                                                      cstr objName x+                                   case m of+                                     Unsatisfiable{} -> return Nothing+                                     Unknown{}       -> error "Solver said Unknown!"+                                     ProofError{}    -> error (show res)+                                     _               -> return $ getModelObjectiveValue objName m -        bisect :: Range a -> IO (Maybe [Range a])-        bisect (Range lo hi) = runSMTWith cfg $ do-                                     x <- free_+            mi <- getBound minimize+            ma <- getBound maximize+            case (mi, ma) of+              (Just minV, Just maxV) -> return $ Just $ Range (getGenVal minV) (getGenVal maxV)+              _                      -> return Nothing -                                     let restrict v open closed = case v of-                                                                    Unbounded -> sTrue-                                                                    Open   a  -> x `open`   literal a-                                                                    Closed a  -> x `closed` literal a+        -- Is this range satisfiable? Returns a witness to it.+        witness :: Range a -> Symbolic (SBV a)+        witness (Range lo hi) = do x :: SBV a <- free_ -                                         lower = restrict lo (.>) (.>=)-                                         upper = restrict hi (.<) (.<=)+                                   let restrict v open closed = case v of+                                                                  Unbounded -> sTrue+                                                                  Open   a  -> x `open`   literal a+                                                                  Closed a  -> x `closed` literal a -                                     constrain $ lower .&& upper .&& sNot (prop x)+                                       lower = restrict lo (.>) (.>=)+                                       upper = restrict hi (.<) (.<=) -                                     query $ do cs <- checkSat-                                                case cs of-                                                  Unsat -> return Nothing-                                                  Unk   -> error "Data.SBV.interval.bisect: Solver said unknown!"-                                                  Sat   -> do midV <- Open <$> getValue x-                                                              return $ Just [Range lo midV, Range midV hi]+                                   constrain $ lower .&& upper +                                   return x++        isFeasible :: Range a -> IO Bool+        isFeasible r = runSMTWith cfg $ do _ <- witness r++                                           query $ do cs <- checkSat+                                                      case cs of+                                                        Unsat -> return False+                                                        Unk   -> error "Data.SBV.interval.isFeasible: Solver said unknown!"+                                                        Sat   -> return True++        bisect :: Range a -> IO (Maybe [Range a])+        bisect r@(Range lo hi) = runSMTWith cfg $ do x <- witness r++                                                     constrain $ sNot (prop x)++                                                     query $ do cs <- checkSat+                                                                case cs of+                                                                  Unsat -> return Nothing+                                                                  Unk   -> error "Data.SBV.interval.bisect: Solver said unknown!"+                                                                  Sat   -> do midV <- Open <$> getValue x+                                                                              return $ Just [Range lo midV, Range midV hi]+         search :: [Range a] -> [Range a] -> IO [Range a]         search []     sofar = return $ reverse sofar-        search (c:cs) sofar = do mbCS <- bisect c-                                 case mbCS of-                                   Nothing  -> search cs          (c:sofar)-                                   Just xss -> search (xss ++ cs) sofar+        search (c:cs) sofar = do feasible <- isFeasible c+                                 if feasible+                                    then do mbCS <- bisect c+                                            case mbCS of+                                              Nothing  -> search cs          (c:sofar)+                                              Just xss -> search (xss ++ cs) sofar+                                    else search cs sofar  {-# ANN rangesWith ("HLint: ignore Replace case with fromMaybe" :: String) #-}
Data/SBV/Trans.hs view
@@ -80,11 +80,12 @@   -- * Enumerations   , mkSymbolicEnumeration -  -- * Uninterpreted sorts, constants, and functions+  -- * Uninterpreted sorts, axioms, constants, and functions   , Uninterpreted(..), addAxiom    -- * Properties, proofs, and satisfiability   , Predicate, Goal, MProvable(..), Provable, proveWithAll, proveWithAny , satWithAll+  , proveConcurrentWithAny, proveConcurrentWithAll, satConcurrentWithAny, satConcurrentWithAll   , satWithAny, generateSMTBenchmark   , solve   -- * Constraints
Data/SBV/Trans/Control.hs view
@@ -28,7 +28,7 @@       -- * Querying the solver      -- ** Extracting values-     , SMTValue(..), getValue, getFunction, getUninterpretedValue, getModel, getAssignment, getSMTResult, getUnknownReason, getObservables+     , getValue, getFunction, getUninterpretedValue, getModel, getAssignment, getSMTResult, getUnknownReason, getObservables       -- ** Extracting the unsat core      , getUnsatCore@@ -77,7 +77,7 @@ import Data.SBV.Core.Symbolic (MonadQuery(..), QueryT, Query, SymbolicT, QueryContext(..))  import Data.SBV.Control.Query-import Data.SBV.Control.Utils (SMTValue(..), queryDebug, executeQuery, getFunction)+import Data.SBV.Control.Utils (queryDebug, executeQuery, getFunction)  import Data.SBV.Utils.ExtractIO
Data/SBV/Utils/SExpr.hs view
@@ -147,6 +147,7 @@         cvt (EApp [ECon "/", ENum  a, ENum  b])                    = return $ EReal (fromInteger (fst a) / fromInteger (fst b))         cvt (EApp [ECon "-", EReal a])                             = return $ EReal (-a)         cvt (EApp [ECon "-", ENum a])                              = return $ ENum  (-(fst a), snd a)+         -- bit-vector value as CVC4 prints: (_ bv0 16) for instance         cvt (EApp [ECon "_", ENum a, ENum _b])                     = return $ ENum a         cvt (EApp [ECon "root-obj", EApp (ECon "+":trms), ENum k]) = do ts <- mapM getCoeff trms@@ -155,6 +156,18 @@         cvt (EApp [ECon "as", n, EApp [ECon "_", ECon "FloatingPoint", ENum ( 8, _), ENum (24, _)]]) = getFloat  n         cvt (EApp [ECon "as", n, ECon "Float64"])                                                    = getDouble n         cvt (EApp [ECon "as", n, ECon "Float32"])                                                    = getFloat  n++        -- Deal with CVC4's approximate reals+        cvt x@(EApp [ECon "witness", EApp [EApp [ECon v, ECon "Real"]]+                                   , EApp [ECon "or", EApp [ECon "=", ECon v', val], _]]) | v == v'   = do+                                                approx <- cvt val+                                                case approx of+                                                  ENum (s, _) -> return $ EReal $ mkPolyReal (Left (False, show s))+                                                  EReal aval  -> case aval of+                                                                   AlgRational _ r -> return $ EReal $ AlgRational False r+                                                                   _               -> return $ EReal aval+                                                  _           -> die $ "Cannot parse a CVC4 approximate value from: " ++ show x+         -- NB. Note the lengths on the mantissa for the following two are 23/52; not 24/53!         cvt (EApp [ECon "fp",    ENum (s, Just 1), ENum ( e, Just 8),  ENum (m, Just 23)])           = return $ EFloat  $ getTripleFloat  s e m         cvt (EApp [ECon "fp",    ENum (s, Just 1), ENum ( e, Just 11), ENum (m, Just 52)])           = return $ EDouble $ getTripleDouble s e m
Documentation/SBV/Examples/Existentials/Diophantine.hs view
@@ -74,15 +74,15 @@ -- We have: -- -- >>> test--- NonHomogeneous [[1,0,0],[0,2,0]] [[0,1,1],[1,0,2]]+-- NonHomogeneous [[0,2,0],[1,0,0]] [[0,1,1],[1,0,2]] -- -- which means that the solutions are of the form: -----    @(1, 0, 0) + k (0, 1, 1) + k' (1, 0, 2) = (1+k', k, k+2k')@+--    @(0, 2, 0) + k (0, 1, 1) + k' (1, 0, 2) = (k', 2+k, k+2k')@ -- -- OR -----    @(0, 2, 0) + k (0, 1, 1) + k' (1, 0, 2) = (k', 2+k, k+2k')@+--    @(1, 0, 0) + k (0, 1, 1) + k' (1, 0, 2) = (1+k', k, k+2k')@ -- -- for arbitrary @k@, @k'@. It's easy to see that these are really solutions -- to the equation given. It's harder to see that they cover all possibilities,
Documentation/SBV/Examples/Lists/BoundedMutex.hs view
@@ -98,8 +98,7 @@ -- so long as both the agents and the arbiter act according to the rules. The check is bounded up-to-the -- given concrete bound; so this is an example of a bounded-model-checking style proof. We have: ----- Test turned off. See: https://github.com/Z3Prover/z3/issues/2956--- checkMutex 20+-- >>> checkMutex 20 -- All is good! checkMutex :: Int -> IO () checkMutex b = runSMT $ do
Documentation/SBV/Examples/Lists/Fibonacci.hs view
@@ -21,6 +21,7 @@ import Data.SBV.Control  -- | Compute a prefix of the fibonacci numbers. We have:+-- -- >>> mkFibs 10 -- [1,1,2,3,5,8,13,21,34,55] mkFibs :: Int -> IO [Integer]
Documentation/SBV/Examples/Misc/Floating.hs view
@@ -58,19 +58,19 @@ -- -- >>> assocPlusRegular -- Falsifiable. Counter-example:---   x =   5.615828e-4 :: Float---   y = -2.2688436e-3 :: Float---   z =    -2047.9991 :: Float+--   x =    128.00029 :: Float+--   y =  -7.27236e-4 :: Float+--   z = -6.875994e-3 :: Float -- -- Indeed, we have: ----- >>> let x =   5.615828e-4 :: Float--- >>> let y = -2.2688436e-3 :: Float--- >>> let z =    -2047.9991 :: Float+-- >>> let x =    128.00029 :: Float+-- >>> let y =  -7.27236e-4 :: Float+-- >>> let z = -6.875994e-3 :: Float -- >>> x + (y + z)--- -2048.001+-- 127.99268 -- >>> (x + y) + z--- -2048.0007+-- 127.99269 -- -- Note the difference in the results! assocPlusRegular :: IO ThmResult@@ -92,13 +92,13 @@ -- -- >>> nonZeroAddition -- Falsifiable. Counter-example:---   a =   -1.9999999 :: Float---   b = 9.403954e-38 :: Float+--   a =  5.060287e28 :: Float+--   b = 3.6780381e19 :: Float -- -- Indeed, we have: ----- >>> let a =   -1.9999999 :: Float--- >>> let b = 9.403954e-38 :: Float+-- >>> let a =  5.060287e28 :: Float+-- >>> let b = 3.6780381e19 :: Float -- >>> a + b == a -- True -- >>> b == 0@@ -121,15 +121,15 @@ -- -- >>> multInverse -- Falsifiable. Counter-example:---   a = -1.910829855912238e-308 :: Double+--   a = 2.4907063e38 :: Float -- -- Indeed, we have: ----- >>> let a = -1.910829855912238e-308 :: Double+-- >>> let a = 2.4907063e38 :: Float -- >>> a * (1/a)--- 0.9999999999999999+-- 1.0000001 multInverse :: IO ThmResult-multInverse = prove $ do a <- sDouble "a"+multInverse = prove $ do a <- sFloat "a"                          constrain $ fpIsPoint a                          constrain $ fpIsPoint (1/a)                          return $ a * (1/a) .== 1@@ -147,33 +147,33 @@ -- -- >>> roundingAdd -- Satisfiable. Model:---   rm = RoundNearestTiesToAway :: RoundingMode---   x  =                    1.0 :: Float---   y  =            -0.43749997 :: Float+--   rm = RoundTowardPositive :: RoundingMode+--   x  =      -2.3509886e-38 :: Float+--   y  =            -6.0e-45 :: Float -- -- (Note that depending on your version of Z3, you might get a different result.) -- Unfortunately we can't directly validate this result at the Haskell level, as Haskell only supports -- 'RoundNearestTiesToEven'. We have: ----- >>> 1.0 + (-0.43749997) :: Float--- 0.5625+-- >>> -2.3509886e-38 + (-6.0e-45) :: Float+-- -2.3509893e-38 ----- While we cannot directly see the result when the mode is 'RoundNearestTiesToAway' in Haskell, we can use+-- While we cannot directly see the result when the mode is 'RoundTowardPositive' in Haskell, we can use -- SBV to provide us with that result thusly: ----- >>> sat $ \z -> z .== fpAdd sRoundNearestTiesToAway 1.0 (-0.43749997 :: SFloat)+-- >>> sat $ \z -> z .== fpAdd sRoundTowardPositive (-2.3509886e-38) (-6.0e-45 :: SFloat) -- Satisfiable. Model:---   s0 = 0.56250006 :: Float+--   s0 = -2.350989e-38 :: Float ----- We can see why these two resuls are indeed different: The 'RoundNearestTiesToAway'--- (which rounds away from zero) produces a larger result. Indeed, if we treat these numbers+-- We can see why these two resuls are indeed different: The 'RoundTowardPositive'+-- (which rounds towards positive infinity from zero) produces a larger result. Indeed, if we treat these numbers -- as 'Double' values, we get: ----- >> 1.0 + (-0.43749997 :: Double)--- 0.56250003+-- >> -2.3509886e-38 + (-6.0e-45) :: Double+-- -2.3509892e-38 -- -- we see that the "more precise" result is larger than what the 'Float' value is, justifying the--- larger value with 'RoundNearestTiesToAway'. A more detailed study is beyond our current scope, so we'll+-- larger value with 'RoundTowardPositive'. A more detailed study is beyond our current scope, so we'll -- merely note that floating point representation and semantics is indeed a thorny -- subject, and point to <http://ece.uwaterloo.ca/~dwharder/NumericalAnalysis/02Numerics/Double/paper.pdf> as -- an excellent guide.
+ Documentation/SBV/Examples/Misc/Newtypes.hs view
@@ -0,0 +1,88 @@+-----------------------------------------------------------------------------+-- |+-- Module    : Documentation.SBV.Examples.Misc.Newtypes+-- Copyright : (c) Curran McConnell+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Demonstrates how to create symbolic newtypes with the same behaviour as+-- their wrapped type.+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror           #-}+{-# LANGUAGE GeneralizedNewtypeDeriving #-}+{-# LANGUAGE ScopedTypeVariables        #-}++module Documentation.SBV.Examples.Misc.Newtypes where++import Prelude hiding (ceiling)+import Data.SBV+import qualified Data.SBV.Internals as SI++-- | A 'Metres' is a newtype wrapper around 'Integer'.+newtype Metres = Metres Integer deriving (Real, Integral, Num, Enum, Eq, Ord)++-- | Symbolic version of 'Metres'.+type SMetres   = SBV Metres++-- | To use 'Metres' symbolically, we associate it with the underlying symbolic+-- type's kind.+instance HasKind Metres where+   kindOf _ = KUnbounded++-- | The 'SymVal' instance simply uses stock definitions. This is always+-- possible for newtypes that simply wrap over an existing symbolic type.+instance SymVal Metres where+   mkSymVal = SI.genMkSymVar KUnbounded+   literal  = SI.genLiteral  KUnbounded+   fromCV   = SI.genFromCV++-- | Similarly, we can create another newtype, this time wrapping over 'Word16'. As an example,+-- consider measuring the human height in centimetres? The tallest person in history,+-- Robert Wadlow, was 272 cm. We don't need negative values, so 'Word16' is the smallest type that+-- suits our needs.+newtype HumanHeightInCm = HumanHeightInCm Word16 deriving (Real, Integral, Num, Enum, Eq, Ord)++-- | Symbolic version of 'HumanHeightInCm'.+type SHumanHeightInCm = SBV HumanHeightInCm++-- | Symbolic instance simply follows the underlying type, just like 'Metres'.+instance HasKind HumanHeightInCm where+    kindOf _ = KBounded False 16++-- | Similarly here, for the 'SymVal' instance.+instance SymVal HumanHeightInCm where+    mkSymVal = SI.genMkSymVar $ KBounded False 16+    literal  = SI.genLiteral  $ KBounded False 16+    fromCV   = SI.genFromCV++-- | The tallest human ever was 272 cm. We can simply use 'literal' to lift it+-- to the symbolic space.+tallestHumanEver :: SHumanHeightInCm+tallestHumanEver = literal 272++-- | Given a distance between a floor and a ceiling, we can see whether+-- the human can stand in that room. Comparison is expressed using 'sFromIntegral'.+ceilingHighEnoughForHuman :: SMetres -> SHumanHeightInCm -> SBool+ceilingHighEnoughForHuman ceiling humanHeight = humanHeight' .< ceiling'+    where -- In a real codebase, the code for comparing these newtypes+          -- should be reusable, perhaps through a typeclass.+        ceiling'     = literal 100 * sFromIntegral ceiling :: SInteger+        humanHeight' = sFromIntegral humanHeight :: SInteger++-- | Now, suppose we want to see whether we could design a room with a ceiling+-- high enough that any human could stand in it. We have:+--+-- >>> sat problem+-- Satisfiable. Model:+--   floorToCeiling =   3 :: Integer+--   humanheight    = 255 :: Word16+problem :: Predicate+problem = do+    ceiling     :: SMetres          <- free "floorToCeiling"+    humanHeight :: SHumanHeightInCm <- free "humanheight"+    constrain $ humanHeight .<= tallestHumanEver++    return $ ceilingHighEnoughForHuman ceiling humanHeight
Documentation/SBV/Examples/Optimization/ExtField.hs view
@@ -24,16 +24,16 @@ -- >>> optimize Independent problem -- Objective "one-x": Optimal in an extension field: --   one-x =                    oo :: Integer---   min_y = 7.0 + (2.0 * epsilon) :: Real---   min_z =         5.0 + epsilon :: Real+--   min_y = 7.0 + (3.0 * epsilon) :: Real+--   min_z = 5.0 + (2.0 * epsilon) :: Real -- Objective "min_y": Optimal in an extension field: --   one-x =                    oo :: Integer---   min_y = 7.0 + (2.0 * epsilon) :: Real---   min_z =         5.0 + epsilon :: Real+--   min_y = 7.0 + (3.0 * epsilon) :: Real+--   min_z = 5.0 + (2.0 * epsilon) :: Real -- Objective "min_z": Optimal in an extension field: --   one-x =                    oo :: Integer---   min_y = 7.0 + (2.0 * epsilon) :: Real---   min_z =         5.0 + epsilon :: Real+--   min_y = 7.0 + (3.0 * epsilon) :: Real+--   min_z = 5.0 + (2.0 * epsilon) :: Real problem :: Goal problem = do x <- sInteger "x"              y <- sReal "y"
Documentation/SBV/Examples/ProofTools/BMC.hs view
@@ -83,7 +83,7 @@ -- BMC: Iteration: 2 -- BMC: Iteration: 3 -- BMC: Solution found at iteration 3--- Right (3,[(0,10),(0,6),(2,6),(2,2)])+-- Right (3,[(0,10),(2,10),(2,6),(2,2)]) -- -- As expected, there's a solution in this case. Furthermore, since the BMC engine -- found a solution at depth @3@, we also know that there is no solution at
Documentation/SBV/Examples/Queries/AllSat.hs view
@@ -20,10 +20,8 @@ import Data.SBV import Data.SBV.Control -import Data.List- -- | Find all solutions to @x + y .== 10@ for positive @x@ and @y@, but at each--- iteration we would like to ensure that the value of @x@ we get is at least twice as large as+-- iteration we would like to ensure that the value of @x@ we get is one more than -- the previous one. This is rather silly, but demonstrates how we can dynamically -- query the result and put in new constraints based on those. goodSum :: Symbolic [(Integer, Integer)]@@ -37,13 +35,16 @@               -- Capture the "next" solution function:              let next i sofar = do-                    io $ putStrLn $ "Iteration: " ++ show (i :: Int)+                    io $ putStrLn $ "Iteration: " ++ show (i :: Integer) -                    cs <- checkSat+                    -- Using a check-sat assuming, we force the solver to walk through+                    -- the entire range of x's+                    cs <- checkSatAssuming [x .== literal (i-1)]+                     case cs of                       Unk   -> error "Too bad, solver said unknown.." -- Won't happen                       Unsat -> do io $ putStrLn "No other solution!"-                                  return sofar+                                  return $ reverse sofar                        Sat   -> do xv <- getValue x                                   yv <- getValue y@@ -56,9 +57,6 @@                                   constrain $   x ./= literal xv                                             .|| y ./= literal yv -                                  -- Also request @x@ to be twice as large, for demo purposes:-                                  constrain $ x .>= 2 * literal xv-                                   -- loop around!                                   next (i+1) ((xv, yv) : sofar) @@ -77,12 +75,23 @@ -- Iteration: 3 -- Current solution is: (2,8) -- Iteration: 4--- Current solution is: (4,6)+-- Current solution is: (3,7) -- Iteration: 5--- Current solution is: (8,2)+-- Current solution is: (4,6) -- Iteration: 6+-- Current solution is: (5,5)+-- Iteration: 7+-- Current solution is: (6,4)+-- Iteration: 8+-- Current solution is: (7,3)+-- Iteration: 9+-- Current solution is: (8,2)+-- Iteration: 10+-- Current solution is: (9,1)+-- Iteration: 11+-- Current solution is: (10,0)+-- Iteration: 12 -- No other solution!--- [(0,10),(1,9),(2,8),(4,6),(8,2)]+-- [(0,10),(1,9),(2,8),(3,7),(4,6),(5,5),(6,4),(7,3),(8,2),(9,1),(10,0)] demo :: IO ()-demo = do ss <- runSMT goodSum-          print $ sort ss+demo = print =<< runSMT goodSum
+ Documentation/SBV/Examples/Queries/Concurrency.hs view
@@ -0,0 +1,170 @@+-----------------------------------------------------------------------------+-- |+-- Module    : Documentation.SBV.Examples.Queries.Concurrency+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- When we would like to solve a set of related problems we can use query mode+-- to perform push's and pop's. However performing a push and a pop is still+-- single threaded and so each solution will need to wait for the previous+-- solution to be found. In this example we show a class of functions+-- 'Data.SBV.satConcurrentAll' and 'Data.SBV.satConcurrentAny' which spin up+-- independent solver instances and runs query computations concurrently. The+-- children query computations are allowed to communicate with one another as+-- demonstrated in the second demo+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror #-}++module Documentation.SBV.Examples.Queries.Concurrency where++import Data.SBV+import Data.SBV.Control+import Control.Concurrent+import Control.Monad.IO.Class (liftIO)++-- | Find all solutions to @x + y .== 10@ for positive @x@ and @y@, but at each+-- iteration we would like to ensure that the value of @x@ we get is at least+-- twice as large as the previous one. This is rather silly, but demonstrates+-- how we can dynamically query the result and put in new constraints based on+-- those.+shared :: MVar (SInteger, SInteger) -> Symbolic ()+shared v = do+  x <- sInteger "x"+  y <- sInteger "y"+  constrain $ y .<= 10+  constrain $ x .<= 10+  constrain $ x + y .== 10+  liftIO $ putMVar v (x,y)++-- | In our first query we'll define a constraint that will not be known to the+-- shared or second query and then solve for an answer that will differ from the+-- first query. Note that we need to pass an MVar in so that we can operate on+-- the shared variables. In general, the variables you want to operate on should+-- be defined in the shared part of the query and then passed to the children+-- queries via channels, MVars, or TVars. In this query we constrain x to be+-- less than y and then return the sum of the values. We add a threadDelay just+-- for demonstration purposes+queryOne :: MVar (SInteger, SInteger) -> Query (Maybe Integer)+queryOne v = do+  io $ putStrLn $ "[One]: Waiting"+  liftIO $ threadDelay 5000000+  io $ putStrLn $ "[One]: Done"+  (x,y) <- liftIO $ takeMVar v+  constrain $ x .< y++  cs <- checkSat+  case cs of+    Unk   -> error "Too bad, solver said unknown.." -- Won't happen+    Unsat -> do io $ putStrLn "No other solution!"+                return Nothing++    Sat   -> do xv <- getValue x+                yv <- getValue y+                io $ putStrLn $ "[One]: Current solution is: " ++ show (xv, yv)+                return $ Just (xv + yv)++-- | In the second query we constrain for an answer where y is smaller than x,+-- and then return the product of the found values.+queryTwo :: MVar (SInteger, SInteger) -> Query (Maybe Integer)+queryTwo v = do+  (x,y) <- liftIO $ takeMVar v+  io $ putStrLn $ "[Two]: got values" ++ show (x,y)+  constrain $ y .< x++  cs <- checkSat+  case cs of+    Unk   -> error "Too bad, solver said unknown.." -- Won't happen+    Unsat -> do io $ putStrLn "No other solution!"+                return Nothing++    Sat   -> do yv <- getValue y+                xv <- getValue x+                io $ putStrLn $ "[Two]: Current solution is: " ++ show (xv, yv)+                return $ Just (xv * yv)++-- | Run the demo several times to see that the children threads will change ordering.+demo :: IO ()+demo = do+  v <- newEmptyMVar+  putStrLn $ "[Main]: Hello from main, kicking off children: "+  results <- satConcurrentWithAll z3 [queryOne v, queryTwo v] (shared v)+  putStrLn $ "[Main]: Children spawned, waiting for results"+  putStrLn $ "[Main]: Here they are: "+  putStrLn $ show results++-- | Example computation.+sharedDependent :: MVar (SInteger, SInteger) -> Symbolic ()+sharedDependent v = do -- constrain positive and sum:+  x <- sInteger "x"+  y <- sInteger "y"+  constrain $ y .<= 10+  constrain $ x .<= 10+  constrain $ x + y .== 10+  liftIO $ putMVar v (x,y)++-- | In our first query we will make a constrain, solve the constraint and+-- return the values for our variables, then we'll mutate the MVar sending+-- information to the second query. Note that you could use channels, or TVars,+-- or TMVars, whatever you need here, we just use MVars for demonstration+-- purposes. Also note that this effectively creates an ordering between the+-- children queries+firstQuery :: MVar (SInteger, SInteger) -> MVar (SInteger , SInteger) -> Query (Maybe Integer)+firstQuery v1 v2 = do+  (x,y) <- liftIO $ takeMVar v1+  io $ putStrLn $ "[One]: got vars...working..."+  constrain $ x .< y++  cs <- checkSat+  case cs of+    Unk   -> error "Too bad, solver said unknown.." -- Won't happen+    Unsat -> do io $ putStrLn "No other solution!"+                return Nothing++    Sat   -> do xv <- getValue x+                yv <- getValue y+                io $ putStrLn $ "[One]: Current solution is: " ++ show (xv, yv)+                io $ putStrLn $ "[One]: Place vars for [Two]"+                liftIO $ putMVar v2 (literal (xv + yv), literal (xv * yv))+                return $ Just (xv + yv)++-- | In the second query we create a new variable z, and then a symbolic query+-- using information from the first query and return a solution that uses the+-- new variable and the old variables. Each child query is run in a separate+-- instance of z3 so you can think of this query as driving to a point in the+-- search space, then waiting for more information, once it gets that+-- information it will run a completely separate computation from the first one+-- and return its results.+secondQuery :: MVar (SInteger, SInteger) -> Query (Maybe Integer)+secondQuery v2 = do+  (x,y) <- liftIO $ takeMVar v2+  io $ putStrLn $ "[Two]: got values" ++ show (x,y)+  z <- freshVar "z"+  constrain $ z .> x + y++  cs <- checkSat+  case cs of+    Unk   -> error "Too bad, solver said unknown.." -- Won't happen+    Unsat -> do io $ putStrLn "No other solution!"+                return Nothing++    Sat   -> do yv <- getValue y+                xv <- getValue x+                zv <- getValue z+                io $ putStrLn $ "[Two]: My solution is: " ++ show (zv + xv, zv + yv)+                return $ Just (zv * xv * yv)++-- | In our second demonstration we show how through the use of concurrency+-- constructs the user can have children queries communicate with one another.+-- Note that the children queries are independent and so anything side-effectual+-- like a push or a pop will be isolated to that child thread, unless of course+-- it happens in shared.+demoDependent :: IO ()+demoDependent = do+  v1 <- newEmptyMVar+  v2 <- newEmptyMVar+  results <- satConcurrentWithAll z3 [firstQuery v1 v2, secondQuery v2] (sharedDependent v1)+  print results
Documentation/SBV/Examples/Uninterpreted/Multiply.hs view
@@ -61,15 +61,14 @@ -- and if you work out the truth-table presented, you'll see that it is exactly that. Of course, -- you can use SBV to prove this. First, define the model we were given to make it symbolic: ----- >>> :{--- mul22_hi :: SBool -> SBool -> SBool -> SBool -> SBool+--- mul22_hi :: SBool -> SBool -> SBool -> SBool -> SBool -- mul22_hi a1 a0 b1 b0 = ite ([a1, a0, b1, b0] .== [sFalse, sTrue , sTrue , sFalse]) sTrue --                      $ ite ([a1, a0, b1, b0] .== [sFalse, sTrue , sTrue , sTrue ]) sTrue --                      $ ite ([a1, a0, b1, b0] .== [sTrue , sFalse, sFalse, sTrue ]) sTrue --                      $ ite ([a1, a0, b1, b0] .== [sTrue , sFalse, sTrue , sTrue ]) sTrue --                      $ ite ([a1, a0, b1, b0] .== [sTrue , sTrue , sFalse, sTrue ]) sTrue --                      $ ite ([a1, a0, b1, b0] .== [sTrue , sTrue , sTrue , sFalse]) sTrue---                        sFalse+--                        sFalse- >>> :{ -- :} -- -- Now we can say:
+ Documentation/SBV/Examples/WeakestPreconditions/Basics.hs view
@@ -0,0 +1,176 @@+-----------------------------------------------------------------------------+-- |+-- Module    : Documentation.SBV.Examples.WeakestPreconditions.Basics+-- Copyright : (c) Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Some basic aspects of weakest preconditions, demostrating programs+-- that do not use while loops. We use a simple increment program as+-- an example.+-----------------------------------------------------------------------------++{-# LANGUAGE DeriveAnyClass        #-}+{-# LANGUAGE DeriveFoldable        #-}+{-# LANGUAGE DeriveGeneric         #-}+{-# LANGUAGE DeriveTraversable     #-}+{-# LANGUAGE FlexibleInstances     #-}+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE NamedFieldPuns        #-}++{-# OPTIONS_GHC -Wall -Werror #-}++module Documentation.SBV.Examples.WeakestPreconditions.Basics where++import Data.SBV+import Data.SBV.Control++import Data.SBV.Tools.WeakestPreconditions++import GHC.Generics (Generic)++-- * Program state++-- | The state for the swap program, parameterized over a base type @a@.+data IncS a = IncS { x :: a    -- ^ Input value+                   , y :: a    -- ^ Output+                   }+                   deriving (Show, Generic, Mergeable, Functor, Foldable, Traversable)++-- | Show instance for 'IncS'. The above deriving clause would work just as well,+-- but we want it to be a little prettier here, and hence the @OVERLAPS@ directive.+instance {-# OVERLAPS #-} (SymVal a, Show a) => Show (IncS (SBV a)) where+   show (IncS x y) = "{x = " ++ sh x ++ ", y = " ++ sh y ++ "}"+     where sh v = case unliteral v of+                    Nothing -> "<symbolic>"+                    Just l  -> show l++-- | 'Fresh' instance for the program state+instance SymVal a => Fresh IO (IncS (SBV a)) where+  fresh = IncS <$> freshVar_  <*> freshVar_++-- | Helper type synonym+type I = IncS SInteger++-- * The algorithm++-- | The increment algorithm:+--+-- @+--    y = x+1+-- @+--+-- The point here isn't really that this program is interesting, but we want to+-- demonstrate various aspects of WP proofs. So, we take a before and after+-- program to annotate our algorithm so we can experiment later.+algorithm :: Stmt I -> Stmt I -> Stmt I+algorithm before after = Seq [ before+                             , Assign $ \st@IncS{x} -> st{y = x+1}+                             , after+                             ]++-- | Precondition for our program. Strictly speaking, we don't really need any preconditions,+-- but for example purposes, we'll require @x@ to be non-negative.+pre :: I -> SBool+pre IncS{x} = x .>= 0++-- | Postcondition for our program: @y@ must @x+1@.+post :: I -> SBool+post IncS{x, y} = y .== x+1++-- | Stability: @x@ must remain unchanged.+noChange :: Stable I+noChange = [stable "x" x]++-- | A program is the algorithm, together with its pre- and post-conditions.+imperativeInc :: Stmt I -> Stmt I -> Program I+imperativeInc before after = Program { setup         = return ()+                                     , precondition  = pre+                                     , program       = algorithm before after+                                     , postcondition = post+                                     , stability     = noChange+                                     }++-- * Correctness++-- | State the correctness with respect to before/after programs. In the simple+-- case of nothing prior/after, we have the obvious proof:+--+-- >>> correctness Skip Skip+-- Total correctness is established.+-- Q.E.D.+correctness :: Stmt I -> Stmt I -> IO (ProofResult (IncS Integer))+correctness before after = wpProveWith defaultWPCfg{wpVerbose=True} (imperativeInc before after)++-- * Example proof attempts+--+-- $examples++{- $examples+It is instructive to look at how the proof changes as we put in different @pre@ and @post@ values.++== Violating the post condition++If we stick in an extra increment for @y@ after, we can easily break the postcondition:++>>> :set -XNamedFieldPuns+>>> import Control.Monad (void)+>>> void $ correctness Skip $ Assign $ \st@IncS{y} -> st{y = y+1}+Following proof obligation failed:+==================================+  Postcondition fails:+    Start: IncS {x = 0, y = 0}+    End  : IncS {x = 0, y = 2}++We're told that the program ends up in a state where @x=0@ and @y=2@, violating the requirement @y=x+1@, as expected.++== Using 'assert'++There are two main use cases for 'assert', which merely ends up being a call to 'Abort'.+One is making sure the inputs are well formed. And the other is the user putting in their+own invariants into the code.++Let's assume that we only want to accept strictly positive values of @x@. We can try:++>>> void $ correctness (assert "x > 0" (\st@IncS{x} -> x .> 0)) Skip+Following proof obligation failed:+==================================+  Abort "x > 0" condition is satisfiable:+    Before: IncS {x = 0, y = 0}+    After : IncS {x = 0, y = 0}++Recall that our precondition ('pre') required @x@ to be non-negative. So, we can put in something weaker and it would be fine:++>>> void $ correctness (assert "x > -5" (\st@IncS{x} -> x .> -5)) Skip+Total correctness is established.++In this case the precondition to our program ensures that the 'assert' will always be satisfied.++As another example, let us put a post assertion that @y@ is even:++>>> void $ correctness Skip (assert "y is even" (\st@IncS{y} -> y `sMod` 2 .== 0))+Following proof obligation failed:+==================================+  Abort "y is even" condition is satisfiable:+    Before: IncS {x = 0, y = 0}+    After : IncS {x = 0, y = 1}++It is important to emphasize that you can put whatever invariant you might want:++>>> void $ correctness Skip (assert "y > x" (\st@IncS{x, y} -> y .> x))+Total correctness is established.++== Violating stability++What happens if our program modifies @x@? After all, we can simply set @x=10@ and @y=11@ and our post condition would be satisfied:++>>> void $ correctness Skip (Assign $ \st -> st{x = 10, y = 11})+Following proof obligation failed:+==================================+  Stability fails for "x":+    Before: IncS {x = 0, y = 1}+    After : IncS {x = 10, y = 11}++So, the stability condition prevents programs from cheating!+-}
Documentation/SBV/Examples/WeakestPreconditions/Fib.hs view
@@ -50,7 +50,7 @@                     Just l  -> show l  -- | 'Fresh' instance for the program state-instance (SymVal a, SMTValue a) => Fresh IO (FibS (SBV a)) where+instance SymVal a => Fresh IO (FibS (SBV a)) where   fresh = FibS <$> freshVar_  <*> freshVar_  <*> freshVar_ <*> freshVar_  -- | Helper type synonym
Documentation/SBV/Examples/WeakestPreconditions/GCD.hs view
@@ -56,7 +56,7 @@                     Just l  -> show l  -- | 'Fresh' instance for the program state-instance (SymVal a, SMTValue a) => Fresh IO (GCDS (SBV a)) where+instance SymVal a => Fresh IO (GCDS (SBV a)) where   fresh = GCDS <$> freshVar_  <*> freshVar_  <*> freshVar_ <*> freshVar_  -- | Helper type synonym
Documentation/SBV/Examples/WeakestPreconditions/IntDiv.hs view
@@ -49,7 +49,7 @@                     Just l  -> show l  -- | 'Fresh' instance for the program state-instance (SymVal a, SMTValue a) => Fresh IO (DivS (SBV a)) where+instance SymVal a => Fresh IO (DivS (SBV a)) where   fresh = DivS <$> freshVar_  <*> freshVar_ <*> freshVar_ <*> freshVar_  -- | Helper type synonym
Documentation/SBV/Examples/WeakestPreconditions/IntSqrt.hs view
@@ -53,7 +53,7 @@                     Just l  -> show l  -- | 'Fresh' instance for the program state-instance (SymVal a, SMTValue a) => Fresh IO (SqrtS (SBV a)) where+instance SymVal a => Fresh IO (SqrtS (SBV a)) where   fresh = SqrtS <$> freshVar_  <*> freshVar_ <*> freshVar_ <*> freshVar_  -- | Helper type synonym
Documentation/SBV/Examples/WeakestPreconditions/Sum.hs view
@@ -48,7 +48,7 @@                     Just l  -> show l  -- | 'Fresh' instance for the program state-instance (SymVal a, SMTValue a) => Fresh IO (SumS (SBV a)) where+instance SymVal a => Fresh IO (SumS (SBV a)) where   fresh = SumS <$> freshVar_  <*> freshVar_  <*> freshVar_  -- | Helper type synonym@@ -208,7 +208,7 @@     After : SumS {n = 2, i = 2, s = 3}  Here, we posed the extra incorrect invariant that @s <= i@ must be maintained, and SBV found us a reachable state that violates the invariant. The-show /before/ state indeed satisfies @s <= i@, but the /after/ state does not. Note that the proof fails in this case not because the program+/before/ state indeed satisfies @s <= i@, but the /after/ state does not. Note that the proof fails in this case not because the program is incorrect, but the stipulated invariant is not valid.  == Having a bad measure, Part I@@ -221,8 +221,8 @@ Following proof obligation failed: ==================================   Measure for loop "i < n" is negative:-    State  : SumS {n = 2, i = 1, s = 1}-    Measure: -1+    State  : SumS {n = 3, i = 2, s = 3}+    Measure: -2  The failure is pretty obvious in this case: Measure produces a negative value. @@ -241,5 +241,7 @@     After  : SumS {n = 1, i = 1, s = 1}     Measure: 2 -Clearly, as @i@ increases, so does our bogus measure @n+i@.+Clearly, as @i@ increases, so does our bogus measure @n+i@. Note that a counterexample where @i@ is+negative is also possible for this failure, as the SMT solver will find a counter-example to induction, not+necessarily a reachable state. Obviously, all such failures need to be addressed for the full proof. -}
+ SBVBenchSuite/BenchSuite/Bench/Bench.hs view
@@ -0,0 +1,247 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.Bench.Bench+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Assessing the overhead of calling solving examples via sbv vs individual solvers+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror -fno-warn-orphans #-}+{-# LANGUAGE CPP                       #-}+{-# LANGUAGE ExistentialQuantification #-}+{-# LANGUAGE FlexibleContexts          #-}+{-# LANGUAGE FlexibleInstances         #-}+{-# LANGUAGE GADTs                     #-}+{-# LANGUAGE RankNTypes                #-}+{-# LANGUAGE RecordWildCards           #-}+{-# LANGUAGE ScopedTypeVariables       #-}++module BenchSuite.Bench.Bench+  ( run+  , run'+  , runWith+  , runIOWith+  , runIO+  , runPure+  , rGroup+  , runOverheadBenchMark+  , runBenchMark+  , onConfig+  , onDesc+  , runner+  , onProblem+  , Runner(..)+  , using+  ) where++import           Control.DeepSeq         (NFData (..), rwhnf)+import           System.Directory        (getCurrentDirectory)+import           System.IO+import           System.IO.Silently      (silence)++import           Gauge.Main++import qualified System.Process          as P+import qualified Utils.SBVBenchFramework as U++-- | The type of the problem to benchmark. This allows us to operate on Runners+-- as values themselves yet still have a unified interface with gauge.+data Problem = forall a . U.Provable a => Problem a++-- | Similarly to Problem, BenchResult is boilerplate for a nice api+data BenchResult = forall a . (Show a, NFData a) => BenchResult a++-- | A bench unit is a solver and a problem that represents an input problem+-- for the solver to solve+type BenchUnit = (U.SMTConfig, FilePath)++-- | A runner is anything that allows the solver to solve, such as:+-- 'Data.SBV.proveWith' or 'Data.SBV.satWith'. We utilize existential types to+-- lose type information and create a unified interface with gauge. We+-- require a runner in order to generate a 'Data.SBV.transcript' and then to run+-- the actual benchmark. We bundle this redundantly into a record so that the+-- benchmarks can be defined in each respective module, with the run function+-- that makes sense for that problem, and then redefined in 'SBVBench'. This is+-- useful because problems that require 'Data.SBV.allSatWith' can lead to a lot+-- of variance in the benchmarking data. Single benchmark runners like+-- 'Data.SBV.satWith' and 'Data.SBV.proveWith' work best.+data RunnerI = RunnerI { runI        :: (U.SMTConfig -> Problem -> IO BenchResult)+                       , config      :: U.SMTConfig+                       , description :: String+                       , problem     :: Problem+                       }++-- | GADT to allow arbritrary nesting of runners. This copies criterion's design+-- so that we don't have to separate out runners that run a single benchmark+-- from runners that need to run several benchmarks+data Runner where+  RBenchmark  :: Benchmark -> Runner    -- ^ a wrapper around gauge benchmarks+  Runner      :: RunnerI   -> Runner    -- ^ a single run+  RunnerGroup :: [Runner]  -> Runner    -- ^ a group of runs++-- | Convenience boilerplate functions, simply avoiding a lens dependency+using :: Runner -> (Runner -> Runner) -> Runner+using = flip ($)++-- | Set the runner function+runner :: (Show c, NFData c) =>+  (forall a. U.Provable a => U.SMTConfig -> a -> IO c) -> Runner -> Runner+runner r' (Runner r@RunnerI{..}) = Runner $ r{runI = toRun r'}+runner r' (RunnerGroup rs)       = RunnerGroup $ runner r' <$> rs+runner _  x                      = x++toRun :: (Show c, NFData c) =>+  (forall a. U.Provable a => U.SMTConfig -> a -> IO c)+  -> U.SMTConfig+  -> Problem+  -> IO BenchResult+toRun f c p = BenchResult <$> helper p+  -- similar to helper in onProblem, this is lmap from profunctor land, i.e., we+  -- curry with a config, then change the runner function from (a -> IO c), to+  -- (Problem -> IO c)+  where helper (Problem a) = f c a++onConfig :: (U.SMTConfig -> U.SMTConfig) -> RunnerI -> RunnerI+onConfig f r@RunnerI{..} = r{config = f config}++onDesc :: (String -> String) -> RunnerI -> RunnerI+onDesc f r@RunnerI{..} = r{description = f description}++onProblem :: (forall a. a -> a) -> RunnerI -> RunnerI+onProblem f r@RunnerI{..} = r{problem = (helper problem)}+  where+    -- helper function to avoid profunctor dependency, this is simply fmap, or+    -- rmap for profunctor land+    helper :: Problem -> Problem+    helper (Problem p) = Problem $ f p+++-- | Filepath to /dev/null+devNull :: FilePath+#ifndef WINDOWS+devNull = "/dev/null"+#else+devNull = "NUL"+#endif++-- | to bench a solver without interfacing through SBV we call transcript to+-- have SBV generate the input file for the solver and then create a process to+-- initiate execution on the solver. Note that we redirect stdout to /dev/devNull+-- or NUL on windows+runStandaloneSolver :: BenchUnit -> IO ()+runStandaloneSolver (slvr, fname) =+  withFile devNull WriteMode $+  (\h -> do (_,_,_,ph) <- P.createProcess (P.shell command){P.std_out = P.UseHandle h}+            _ <- P.waitForProcess ph+            return ())+  where command = U.mkExecString slvr fname++-- | Given a file name, a solver config, and a problem to solve, create an+-- environment for the gauge benchmark by generating a transcript file+standaloneEnv :: RunnerI -> IO FilePath -> IO BenchUnit+standaloneEnv RunnerI{..} f = f >>= go problem+  where+    -- generate a transcript for the unit+    go p file = do pwd <- getCurrentDirectory+                   let fPath = mconcat [pwd,"/",file]+                   _ <- runI config{U.transcript = Just fPath} p >> return ()+                   return (config,fPath)++-- | Cleanup the environment created by gauge by removing the transcript file+-- used to run the standalone solver+standaloneCleanup :: BenchUnit -> IO ()+standaloneCleanup (_,fPath) =  P.callCommand $ "rm " ++ fPath++-- | To construct a benchmark to test SBV's overhead we setup an environment+-- with gauge where a symbolic computation is emitted to a transcript file.+-- To test the solver without respect to SBV (standalone) we pass the transcript+-- file to the solver using the same primitives SBV does. Not that mkFileName+-- generates a random filename that is removed at the end of the benchmark. This+-- function exposes the solver and the solve interface in case the user would+-- like to benchmark with something other than 'Data.SBV.z3' and so that we can+-- benchmark all solving variants, e.g., 'Data.SBV.proveWith',+-- 'Data.SBV.satWith', 'Data.SBV.allProveWith' etc.+mkOverheadBenchMark' :: RunnerI -> Benchmark+mkOverheadBenchMark' r@RunnerI{..} =+  envWithCleanup+  (standaloneEnv r U.mkFileName)+  standaloneCleanup $+  \ ~unit ->+    bgroup description [ bench "standalone" $ nfIO $ runStandaloneSolver unit+                       -- notice for sbv benchmark; we pull the solver out of unit and+                       -- use the input problem not the transcript in the unit+                       , bench "sbv"        $ nfIO $ runI (fst unit) problem+                       ]++runOverheadBenchMark :: Runner -> Benchmark+runOverheadBenchMark (Runner r@RunnerI{..}) = mkOverheadBenchMark' r+runOverheadBenchMark (RunnerGroup rs)       = bgroup "" $ -- leave the description close to the benchmark/problem definition+                                             runOverheadBenchMark <$> rs+runOverheadBenchMark (RBenchmark b)         = b+++-- | make a normal benchmark without the overhead comparision. Notice this is+-- just unpacking the Runner record+mkBenchMark :: RunnerI -> Benchmark+mkBenchMark RunnerI{..} = bgroup description [bench "" . nfIO $! runI config problem]++-- | Convert a Runner or a group of Runners to Benchmarks, this is an api level+-- function to convert the runners defined in each file to benchmarks which can+-- be run by gauge+runBenchMark :: Runner -> Benchmark+runBenchMark (Runner r@RunnerI{..}) = mkBenchMark r+runBenchMark (RunnerGroup rs)       = bgroup "" $ runBenchMark <$> rs+runBenchMark (RBenchmark b)         = b++-- | This is just a wrapper around the RunnerI constructor and serves as the main+-- entry point to make a runner for a user in case they need something custom.+run' :: (NFData b, Show b) =>+  (forall a. U.Provable a => U.SMTConfig -> a -> IO b)+  -> U.SMTConfig+  -> String+  -> Problem+  -> Runner+run' r config description problem = Runner $ RunnerI{..}+  where runI = toRun r++-- | Convenience function for creating benchmarks that exposes a configuration+runWith :: U.Provable a => U.SMTConfig -> String -> a -> Runner+runWith c d p = run' U.satWith c d (Problem p)++-- | Main entry point for simple benchmarks. See 'mkRunner'' or 'mkRunnerWith'+-- for versions of this function that allows custom inputs. If you have some use+-- case that is not considered then you can simply overload the record fields.+run :: U.Provable a => String -> a -> Runner+run d p = runWith U.z3 d p `using` runner U.satWith++-- | Entry point for problems that return IO or to benchmark IO results+runIOWith :: NFData a => (a -> Benchmarkable) -> String -> a -> Runner+runIOWith f d = RBenchmark . bench d . f++-- | Benchmark an IO result of sbv, this could be codegen, return models, etc..+-- See @runIOWith@ for a version which allows the consumer to select the+-- Benchmarkable injection function+runIO :: NFData a => String -> IO a -> Runner+runIO d = RBenchmark . bench d . nfIO . silence++-- | Benchmark an pure result+runPure :: NFData a => String -> (a -> b) -> a -> Runner+runPure d = (RBenchmark . bench d) .: whnf+  where (.:) = (.).(.)++-- | create a runner group. Useful for benchmarks that need to run several+-- benchmarks. See 'BenchSuite.Puzzles.NQueens' for an example.+rGroup :: [Runner] -> Runner+rGroup = RunnerGroup++-- | Orphaned instances just for benchmarking+instance NFData U.AllSatResult where+  rnf (U.AllSatResult (a, b, c, results)) =+    rnf a `seq` rnf b `seq` rnf c `seq` rwhnf results++-- | Unwrap the existential type to make gauge happy+instance NFData BenchResult where rnf (BenchResult a) = rnf a
+ SBVBenchSuite/BenchSuite/BitPrecise/BitTricks.hs view
@@ -0,0 +1,27 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.BitPrecise.BitTricks+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.BitPrecise.BitTricks+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror #-}++module BenchSuite.BitPrecise.BitTricks(benchmarks) where++import Documentation.SBV.Examples.BitPrecise.BitTricks+import BenchSuite.Bench.Bench as B++import Data.SBV (proveWith)++-- benchmark suite+benchmarks :: Runner+benchmarks = rGroup+  [ B.run "Fast-min" fastMinCorrect `using` runner proveWith+  , B.run  "Fast-max" fastMaxCorrect `using` runner proveWith+  ]
+ SBVBenchSuite/BenchSuite/BitPrecise/BrokenSearch.hs view
@@ -0,0 +1,42 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.BitPrecise.BrokenSearch+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.BitPrecise.BrokenSearch+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror #-}++module BenchSuite.BitPrecise.BrokenSearch(benchmarks) where++import Documentation.SBV.Examples.BitPrecise.BrokenSearch+import BenchSuite.Bench.Bench as B++import Data.SBV (proveWith,sInt32,(.>=),(.<=),(.==),sFromIntegral,SInt64,sDiv,constrain)++-- benchmark suite+benchmarks :: Runner+benchmarks = rGroup+  [ B.run  "Arith.MidPointFixed"  (checkCorrect midPointFixed)      `using` runner Data.SBV.proveWith+  , B.run  "Arith-Overflow"       (checkCorrect midPointAlternative)  `using` runner Data.SBV.proveWith+  ]++  where checkCorrect f = do low  <- sInt32 "low"+                            high <- sInt32 "high"++                            constrain $ low .>= 0+                            constrain $ low .<= high++                            let low', high' :: SInt64+                                low'  = sFromIntegral low+                                high' = sFromIntegral high+                                mid'  = (low' + high') `sDiv` 2++                                mid   = f low high++                            return $ sFromIntegral mid .== mid'
+ SBVBenchSuite/BenchSuite/BitPrecise/Legato.hs view
@@ -0,0 +1,40 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.BitPrecise.Legato+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.BitPrecise.Legato+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror #-}++module BenchSuite.BitPrecise.Legato(benchmarks) where++import Documentation.SBV.Examples.BitPrecise.Legato+import BenchSuite.Bench.Bench as B++import Data.SBV++-- benchmark suite+benchmarks :: Runner+benchmarks = rGroup+  [ B.run    "Correctness.Legato" correctnessThm `using` runner Data.SBV.proveWith+  , B.runIO  "CodeGen.Legato" legatoInC+  ]+  where correctnessThm = do+          lo <- sWord "lo"++          x <- sWord  "x"+          y <- sWord  "y"++          regX  <- sWord "regX"+          regA  <- sWord "regA"++          flagC <- sBool "flagC"+          flagZ <- sBool "flagZ"++          return $ legatoIsCorrect (x, y, lo, regX, regA, flagC, flagZ)
+ SBVBenchSuite/BenchSuite/BitPrecise/MergeSort.hs view
@@ -0,0 +1,34 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.BitPrecise.MergeSort+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.BitPrecise.MergeSort+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror #-}++module BenchSuite.BitPrecise.MergeSort(benchmarks) where++import Documentation.SBV.Examples.BitPrecise.MergeSort+import BenchSuite.Bench.Bench as B++import Data.SBV++-- benchmark suite+benchmarks :: Runner+benchmarks = rGroup+  [ B.run    "Correctness.MergeSort 10"   (correctness' 10)   `using` runner Data.SBV.proveWith+  , B.run    "Correctness.MergeSort 100"  (correctness' 100)  `using` runner Data.SBV.proveWith+  , B.run    "Correctness.MergeSort 1000" (correctness' 1000) `using` runner Data.SBV.proveWith+  , B.runIO  "CodeGen.MergeSort 10" $ codeGen 10+  , B.runIO  "CodeGen.MergeSort 100" $ codeGen 100+  , B.runIO  "CodeGen.MergeSort 1000" $ codeGen 1000+  ]+  where correctness' n = do xs <- mkFreeVars n+                            let ys = mergeSort xs+                            return $ nonDecreasing ys .&& isPermutationOf xs ys
+ SBVBenchSuite/BenchSuite/BitPrecise/MultMask.hs view
@@ -0,0 +1,31 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.BitPrecise.MultMask+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.BitPrecise.MultMask+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror #-}++module BenchSuite.BitPrecise.MultMask(benchmarks) where++import BenchSuite.Bench.Bench as B++import Data.SBV++-- benchmark suite+benchmarks :: Runner+benchmarks = rGroup+  [ B.runWith conf "MultMask" find+  ]+  where find = do mask <- exists "mask"+                  mult <- exists "mult"+                  inp  <- forall "inp"+                  let res = (mask .&. inp) * (mult :: SWord64)+                  solve [inp `sExtractBits` [7, 15 .. 63] .== res `sExtractBits` [56 .. 63]]+        conf = z3{printBase=16, satCmd = "(check-sat-using (and-then simplify smtfd))"}
+ SBVBenchSuite/BenchSuite/BitPrecise/PrefixSum.hs view
@@ -0,0 +1,27 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.BitPrecise.PrefixSum+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.BitPrecise.PrefixSum+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror #-}++module BenchSuite.BitPrecise.PrefixSum(benchmarks) where++import Documentation.SBV.Examples.BitPrecise.PrefixSum+import BenchSuite.Bench.Bench as B++import Data.SBV++-- benchmark suite+benchmarks :: Runner+benchmarks = rGroup+  [ B.run    "Correctness.PrefixSum 8"  (flIsCorrect 8  (0,(+)))  `using` runner proveWith+  , B.run    "Correctness.PrefixSum 16" (flIsCorrect 16 (0,smax)) `using` runner proveWith+  ]
+ SBVBenchSuite/BenchSuite/CodeGeneration/AddSub.hs view
@@ -0,0 +1,23 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.CodeGeneration.AddSub+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.CodeGeneration.AddSub+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror #-}++module BenchSuite.CodeGeneration.AddSub(benchmarks) where++import Documentation.SBV.Examples.CodeGeneration.AddSub++import BenchSuite.Bench.Bench++-- benchmark suite+benchmarks :: Runner+benchmarks = runIO "genAddSub" genAddSub
+ SBVBenchSuite/BenchSuite/CodeGeneration/CRC_USB5.hs view
@@ -0,0 +1,27 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.CodeGeneration.CRC_USB5+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.CodeGeneration.CRC_USB5+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror #-}++module BenchSuite.CodeGeneration.CRC_USB5(benchmarks) where++import Documentation.SBV.Examples.CodeGeneration.CRC_USB5++import BenchSuite.Bench.Bench++-- benchmark suite+benchmarks :: Runner+benchmarks = rGroup+  [ runIO "Correctness" crcGood+  , runIO "CodeGen 1" cg1+  , runIO "CodeGen 2" cg2+  ]
+ SBVBenchSuite/BenchSuite/CodeGeneration/Fibonacci.hs view
@@ -0,0 +1,30 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.CodeGeneration.Fibonacci+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.CodeGeneration.Fibonacci+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror #-}++module BenchSuite.CodeGeneration.Fibonacci(benchmarks) where++import Documentation.SBV.Examples.CodeGeneration.Fibonacci++import BenchSuite.Bench.Bench++-- benchmark suite+benchmarks :: Runner+benchmarks = rGroup+  [ runIO "Fib1 1"  $ genFib1 1+  , runIO "Fib1 10" $ genFib1 10+  , runIO "Fib1 20" $ genFib1 20+  , runIO "Fib2 1"  $ genFib1 1+  , runIO "Fib2 10" $ genFib1 10+  , runIO "Fib2 20" $ genFib1 20+  ]
+ SBVBenchSuite/BenchSuite/CodeGeneration/GCD.hs view
@@ -0,0 +1,27 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.CodeGeneration.GCD+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.CodeGeneration.GCD+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror #-}++module BenchSuite.CodeGeneration.GCD(benchmarks) where++import Documentation.SBV.Examples.CodeGeneration.GCD+import Data.SBV++import BenchSuite.Bench.Bench++-- benchmark suite+benchmarks :: Runner+benchmarks = rGroup+  [ run "Correctness" sgcdIsCorrect `using` runner proveWith+  , runIO "CodeGen" genGCDInC+  ]
+ SBVBenchSuite/BenchSuite/CodeGeneration/PopulationCount.hs view
@@ -0,0 +1,27 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.CodeGeneration.PopulationCount+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.CodeGeneration.PopulationCount+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror #-}++module BenchSuite.CodeGeneration.PopulationCount(benchmarks) where++import Documentation.SBV.Examples.CodeGeneration.PopulationCount+import Data.SBV++import BenchSuite.Bench.Bench++-- benchmark suite+benchmarks :: Runner+benchmarks = rGroup+  [ run "Correctness" fastPopCountIsCorrect `using` runner proveWith+  , runIO "CodeGen" genPopCountInC+  ]
+ SBVBenchSuite/BenchSuite/CodeGeneration/Uninterpreted.hs view
@@ -0,0 +1,28 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.CodeGeneration.Uninterpreted+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.CodeGeneration.Uninterpreted+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror #-}++module BenchSuite.CodeGeneration.Uninterpreted(benchmarks) where++import Documentation.SBV.Examples.CodeGeneration.Uninterpreted+import Data.SBV++import BenchSuite.Bench.Bench++-- benchmark suite+benchmarks :: Runner+benchmarks = rGroup+  [ run "Correctness" testLeft `using` runner proveWith+  , runIO "CodeGen" genCCode+  ]+  where testLeft = \x y -> tstShiftLeft x y 0 .== x + y
+ SBVBenchSuite/BenchSuite/Crypto/AES.hs view
@@ -0,0 +1,35 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.Crypto.AES+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.Crypto.AES+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror #-}++module BenchSuite.Crypto.AES(benchmarks) where++import Documentation.SBV.Examples.Crypto.AES+import Data.SBV++import BenchSuite.Bench.Bench++-- benchmark suite+benchmarks :: Runner+benchmarks = rGroup+  [ run "InverseGF"               inverseGFPrf       `using` runner proveWith+  , run "Correctness.SBoxInverse" sboxInverseCorrect `using` runner proveWith+  , runPure "t128Enc" (fmap hex8) t128Enc+  , runPure "t128Dec" (fmap hex8) t128Dec+  , runPure "t192Enc" (fmap hex8) t192Enc+  , runPure "t192Dec" (fmap hex8) t192Dec+  , runPure "t256Enc" (fmap hex8) t256Enc+  , runPure "t256Dec" (fmap hex8) t256Dec+  , runIO   "CodeGen.AES128Lib" cgAES128Library+  ]+  where inverseGFPrf = \x -> x ./= 0 .=> x `gf28Mult` gf28Inverse x .== 1
+ SBVBenchSuite/BenchSuite/Crypto/RC4.hs view
@@ -0,0 +1,31 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.Crypto.RC4+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.Crypto.RC4+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror #-}++module BenchSuite.Crypto.RC4(benchmarks) where++import Documentation.SBV.Examples.Crypto.RC4++import BenchSuite.Bench.Bench++-- benchmark suite+benchmarks :: Runner+benchmarks = rGroup+  [ runIO "Correctness" rc4IsCorrect+  , runPure "encrypt 1" (concatMap hex2) $ encrypt "Key" "Plaintext"+  , runPure "encrypt 2" (concatMap hex2) $ encrypt "Wiki" "pedia"+  , runPure "encrypt 3" (concatMap hex2) $ encrypt "Secret" "Attack at dawn"+  , runPure "decrypt 1" (decrypt "Key")    [0xbb, 0xf3, 0x16, 0xe8, 0xd9, 0x40, 0xaf, 0x0a, 0xd3]+  , runPure "decrypt 2" (decrypt "Wiki")   [0x10, 0x21, 0xbf, 0x04, 0x20]+  , runPure "decrypt 3" (decrypt "Secret") [0x45, 0xa0, 0x1f, 0x64, 0x5f, 0xc3, 0x5b, 0x38, 0x35, 0x52, 0x54, 0x4b, 0x9b, 0xf5]+  ]
+ SBVBenchSuite/BenchSuite/Crypto/SHA.hs view
@@ -0,0 +1,28 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.Crypto.SHA+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.Crypto.SHA+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror #-}++module BenchSuite.Crypto.SHA(benchmarks) where++import Documentation.SBV.Examples.Crypto.SHA++import BenchSuite.Bench.Bench++-- benchmark suite+benchmarks :: Runner+benchmarks = rGroup+  [ runIO   "CodeGeneration" cgSHA256+  , runPure "knownTests 1"   knownAnswerTests 1+  , runPure "knownTests 10"  knownAnswerTests 10+  , runPure "knownTests 24"  knownAnswerTests 24+  ]
+ SBVBenchSuite/BenchSuite/Existentials/CRCPolynomial.hs view
@@ -0,0 +1,23 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.Existentials.CRCPolynomial+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.Existentials.CRCPolynomial+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror #-}++module BenchSuite.Existentials.CRCPolynomial(benchmarks) where++import Documentation.SBV.Examples.Existentials.CRCPolynomial++import BenchSuite.Bench.Bench++-- benchmark suite+benchmarks :: Runner+benchmarks =  runIO "FindPolynomials" findHD4Polynomials
+ SBVBenchSuite/BenchSuite/Existentials/Diophantine.hs view
@@ -0,0 +1,31 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.Existentials.Diophantine+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.Existentials.Diophantine+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror -fno-warn-orphans #-}++module BenchSuite.Existentials.Diophantine(benchmarks) where++import Documentation.SBV.Examples.Existentials.Diophantine+import Control.DeepSeq++import BenchSuite.Bench.Bench++-- benchmark suite+benchmarks :: Runner+benchmarks =  rGroup+              [ runIO "Test"    test+              , runIO "Sailors" sailors+              ]++++instance NFData Solution where rnf x = seq x ()
+ SBVBenchSuite/BenchSuite/Lists/BoundedMutex.hs view
@@ -0,0 +1,30 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.Lists.BoundedMutex+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.Lists.BoundedMutex+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror #-}++module BenchSuite.Lists.BoundedMutex(benchmarks) where++import Documentation.SBV.Examples.Lists.BoundedMutex++import BenchSuite.Bench.Bench++-- benchmark suite+benchmarks :: Runner+benchmarks = rGroup+             [ runIO "CheckMutex.1"  $ checkMutex 1+             , runIO "CheckMutex.10" $ checkMutex 10+             , runIO "CheckMutex.20" $ checkMutex 20+             , runIO "NotFair.1"     $ notFair 1+             , runIO "NotFair.10"    $ notFair 10+             , runIO "NotFair.20"    $ notFair 20+             ]
+ SBVBenchSuite/BenchSuite/Lists/Fibonacci.hs view
@@ -0,0 +1,26 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.Lists.Fibonacci+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.Lists.Fibonacci+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror #-}++module BenchSuite.Lists.Fibonacci(benchmarks) where++import Documentation.SBV.Examples.Lists.Fibonacci+import Data.SBV++import BenchSuite.Bench.Bench++-- benchmark suite+benchmarks :: Runner+benchmarks = rGroup+             [ runIO "GenFibs" $ runSMT genFibs+             ]
+ SBVBenchSuite/BenchSuite/Lists/Nested.hs view
@@ -0,0 +1,25 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.Lists.Nested+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.Lists.Nested+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror #-}++module BenchSuite.Lists.Nested(benchmarks) where++import Documentation.SBV.Examples.Lists.Nested++import BenchSuite.Bench.Bench++-- benchmark suite+benchmarks :: Runner+benchmarks = rGroup+             [ runIO "Nested.Example" nestedExample+             ]
+ SBVBenchSuite/BenchSuite/Misc/Auxiliary.hs view
@@ -0,0 +1,25 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.Misc.Auxiliary+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.Misc.Auxiliary+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror #-}++module BenchSuite.Misc.Auxiliary(benchmarks) where++import Documentation.SBV.Examples.Misc.Auxiliary++import BenchSuite.Bench.Bench as S+import Utils.SBVBenchFramework+++-- benchmark suite+benchmarks :: Runner+benchmarks = S.run "Birthday" problem `using` runner allSatWith
+ SBVBenchSuite/BenchSuite/Misc/Enumerate.hs view
@@ -0,0 +1,39 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.Misc.Enumerate+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.Misc.Enumerate+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror #-}+{-# LANGUAGE ScopedTypeVariables #-}++module BenchSuite.Misc.Enumerate(benchmarks) where++import Documentation.SBV.Examples.Misc.Enumerate++import BenchSuite.Bench.Bench+import Utils.SBVBenchFramework+++-- benchmark suite+benchmarks :: Runner+benchmarks = rGroup+             [ run "Elts" _elts `using` runner allSatWith+             , run "Four" _four+             , run "MaxE" _maxE+             , run "MinE" _minE+             ]+  where _elts = \(x::SE) -> x .== x+        _four = \a b c (d::SE) -> distinct [a, b, c, d]+        _maxE = do mx <- exists "maxE"+                   e  <- forall "e"+                   return $ mx .>= (e::SE)+        _minE = do mx <- exists "minE"+                   e  <- forall "e"+                   return $ mx .<= (e::SE)
+ SBVBenchSuite/BenchSuite/Misc/Floating.hs view
@@ -0,0 +1,61 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.Misc.Floating+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.Misc.Floating+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror #-}++{-# LANGUAGE ScopedTypeVariables #-}++module BenchSuite.Misc.Floating(benchmarks) where++import Documentation.SBV.Examples.Misc.Floating++import BenchSuite.Bench.Bench+import Utils.SBVBenchFramework+++-- benchmark suite+benchmarks :: Runner+benchmarks = rGroup+             [ run "notAssoc"        (assocPlus (0/0)) `using` runner proveWith+             , run "AssocPlusReg"    _assocPlusRegular `using` runner proveWith+             , run "NonZeroAddition" _nonZeroAddition  `using` runner proveWith+             , run "MultInverse"     _multInverse      `using` runner proveWith+             , run "RoundingAdd"     _roundingAdd+             ]+  where _assocPlusRegular = do [x, y, z] <- sFloats ["x", "y", "z"]+                               let lhs = x+(y+z)+                                   rhs = (x+y)+z+                               -- make sure we do not overflow at the intermediate points+                               constrain $ fpIsPoint lhs+                               constrain $ fpIsPoint rhs+                               return $ lhs .== rhs++        _nonZeroAddition  = do [a, b] <- sFloats ["a", "b"]+                               constrain $ fpIsPoint a+                               constrain $ fpIsPoint b+                               constrain $ a + b .== a+                               return $ b .== 0++        _multInverse      = do a <- sFloat "a"+                               constrain $ fpIsPoint a+                               constrain $ fpIsPoint (1/a)+                               return $ a * (1/a) .== 1++        _roundingAdd      = do m :: SRoundingMode <- free "rm"+                               constrain $ m ./= literal RoundNearestTiesToEven+                               x <- sFloat "x"+                               y <- sFloat "y"+                               let lhs = fpAdd m x y+                               let rhs = x + y+                               constrain $ fpIsPoint lhs+                               constrain $ fpIsPoint rhs+                               return $ lhs ./= rhs
+ SBVBenchSuite/BenchSuite/Misc/ModelExtract.hs view
@@ -0,0 +1,24 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.Misc.ModelExtract+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.Misc.ModelExtract+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror #-}++module BenchSuite.Misc.ModelExtract(benchmarks) where++import Documentation.SBV.Examples.Misc.ModelExtract++import BenchSuite.Bench.Bench+++-- benchmark suite+benchmarks :: Runner+benchmarks =  runIO "genVals" genVals
+ SBVBenchSuite/BenchSuite/Misc/Newtypes.hs view
@@ -0,0 +1,24 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.Misc.Newtypes+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.Misc.Newtypes+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror #-}++module BenchSuite.Misc.Newtypes(benchmarks) where++import Documentation.SBV.Examples.Misc.Newtypes++import BenchSuite.Bench.Bench+++-- benchmark suite+benchmarks :: Runner+benchmarks =  run "Problem" problem
+ SBVBenchSuite/BenchSuite/Misc/NoDiv0.hs view
@@ -0,0 +1,31 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.Misc.NoDiv0+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.Misc.NoDiv0+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror -fno-warn-orphans #-}++module BenchSuite.Misc.NoDiv0(benchmarks) where++import Documentation.SBV.Examples.Misc.NoDiv0++import Data.SBV+import Control.DeepSeq+import BenchSuite.Bench.Bench+++-- benchmark suite+benchmarks :: Runner+benchmarks = rGroup+             [ runIO "test.1" test1+             , runIO "test.2" test2+             ]++instance NFData SafeResult where rnf x = seq x ()
+ SBVBenchSuite/BenchSuite/Misc/Polynomials.hs view
@@ -0,0 +1,24 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.Misc.Polynomials+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.Misc.Polynomials+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror #-}++module BenchSuite.Misc.Polynomials(benchmarks) where++import Documentation.SBV.Examples.Misc.Polynomials++import BenchSuite.Bench.Bench+++-- benchmark suite+benchmarks :: Runner+benchmarks =  runIO "testGF28 " testGF28
+ SBVBenchSuite/BenchSuite/Misc/SetAlgebra.hs view
@@ -0,0 +1,131 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.Misc.SetAlgebra+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.Misc.SetAlgebra+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror #-}++{-# LANGUAGE ScopedTypeVariables #-}++module BenchSuite.Misc.SetAlgebra(benchmarks) where++import Data.SBV hiding (complement)+import Data.SBV.Set+import Documentation.SBV.Examples.Misc.SetAlgebra++import BenchSuite.Bench.Bench+++-- benchmark suite+benchmarks :: Runner+benchmarks =  rGroup $ fmap (`using` _prove)+              [ run "Commutivity.Union"           commutivityCup+              , run "Commutivity.Intersection"    commutivityCap+              , run "Associativity.Union"         assocCup+              , run "Associativity.Intersection"  assocCap+              , run "Distributivity.Union"        distribCup+              , run "Distributivity.Intersection" distribCap+              , run "Identity.Union"              identCup+              , run "Identity.Intersection"       identCap+              , run "Complement.Union"            compCup+              , run "Complement.Intersection"     compCap+              , run "Complement.Empty"            compEmpty+              , run "Complement.Complement"       compComp+              , run "Complement.Full"             compFull+              , run "Complement.Unique"           compUniq+              , run "Idempotency.Cup"             idempCup+              , run "Idempotency.Cap"             idempCap+              , run "Domination.Cup"              domCup+              , run "Domination.Cap"              domCap+              , run "Absorption.Cup"              absorbCup+              , run "Absorption.Cap"              absorbCap+              , run "Intersection.Difference"     intdiff+              , run "DeMorgans.Cup"               demorgCup+              , run "DeMorgans.Cap"               demorgCap+              , run "InclusionIsPO"               incPo+              , run "SubsetEquality"              subEq+              , run "SubsetEquality.Transitivity" subEqTrans+              , run "JoinMeet.1"                  joinMeet1+              , run "JoinMeet.2"                  joinMeet2+              , run "JoinMeet.3"                  joinMeet3+              , run "JoinMeet.4"                  joinMeet4+              , run "JoinMeet.5"                  joinMeet5+              , run "SubsetChar.Union"            subsetCharCup+              , run "SubsetChar.Intersection"     subsetCharCap+              , run "SubsetChar.Implication"      subsetCharImpl+              , run "SubsetChar.Complement"       subsetCharComp++              , run "RelativeComplements.Union"              relCompCup+              , run "RelativeComplements.Intersection"       relCompCap+              , run "RelativeComplements.UnionInters"        relCompCapCup+              , run "RelativeComplements.InterInters.1"      relCompCapCap+              , run "RelativeComplements.InterInters.2"      relCompCapCap2+              , run "RelativeComplements.UnionUnion"         relCompCupCup+              , run "RelativeComplements.Identity"           relCompIdent+              , run "RelativeComplements.UnitLeft"           relCompUnitL+              , run "RelativeComplements.UnitRight"          relCompUnitR+              , run "RelativeComplements.ComplementIdentity" relCompCompInt+              , run "RelativeComplements.ComplementUnion"    relCompCompUni+              , run "RelativeComplements.CompComp"           relCompComp+              , run "RelativeComplements.CompFull"           relCompFull+              , run "DistributionSubset.Union"               distSubset1+              , run "DistributionSubset.Intersection"        distSubset2+              ]+  where _prove = runner proveWith+        commutivityCup = \(a :: SI) b -> a `union` b .== b `union` a+        commutivityCap = \(a :: SI) b -> a `intersection` b .== b `intersection` a+        assocCup       = \(a :: SI) b c -> a `union` (b `union` c) .== (a `union` b) `union` c+        assocCap       = \(a :: SI) b c -> a `intersection` (b `intersection` c) .== (a `intersection` b) `intersection` c+        distribCup     = \(a :: SI) b c -> a `union` (b `intersection` c) .== (a `union` b) `intersection` (a `union` c)+        distribCap     = \(a :: SI) b c -> a `intersection` (b `union` c) .== (a `intersection` b) `union` (a `intersection` c)+        identCup       = \(a :: SI) -> a `union` empty .== a+        identCap       = \(a :: SI) -> a `intersection` full .== a+        compCup        = \(a :: SI) -> a `union` complement a .== full+        compCap        = \(a :: SI) -> a `intersection` complement a .== empty+        compEmpty      = complement (empty :: SI) .== full+        compComp       = \(a :: SI) -> complement (complement a) .== a+        compFull       = complement (full :: SI) .== empty+        compUniq       = \(a :: SI) b -> a `union` b .== full .&& a `intersection` b .== empty .<=> b .== complement a+        idempCup       = \(a :: SI) -> a `union` a .== a+        idempCap       = \(a :: SI) -> a `intersection` a .== a+        domCup         = \(a :: SI) -> a `union` full .== full+        domCap         = \(a :: SI) -> a `intersection` empty .== empty+        absorbCup      = \(a :: SI) b -> a `union` (a `intersection` b) .== a+        absorbCap      = \(a :: SI) b -> a `intersection` (a `union` b) .== a+        intdiff        = \(a :: SI) b -> a `intersection` b .== a `difference` (a `difference` b)+        demorgCup      = \(a :: SI) b -> complement (a `union` b) .== complement a `intersection` complement b+        demorgCap      = \(a :: SI) b -> complement (a `intersection` b) .== complement a `union` complement b+        incPo          = \(a :: SI) -> a `isSubsetOf` a+        subEq          = \(a :: SI) b -> a `isSubsetOf` b .&& b `isSubsetOf` a .<=> a .== b+        subEqTrans     = \(a :: SI) b c -> a `isSubsetOf` b .&& b `isSubsetOf` c .=> a `isSubsetOf` c+        joinMeet1      = \(a :: SI) b -> a `isSubsetOf` (a `union` b)+        joinMeet2      = \(a :: SI) b c -> a `isSubsetOf` c .&& b `isSubsetOf` c .=> (a `union` b) `isSubsetOf` c+        joinMeet3      = \(a :: SI) b -> (a `intersection` b) `isSubsetOf` a+        joinMeet4      = \(a :: SI) b -> (a `intersection` b) `isSubsetOf` b+        joinMeet5      = \(a :: SI) b c -> c `isSubsetOf` a .&& c `isSubsetOf` b .=> c `isSubsetOf` (a `intersection` b)+        subsetCharCup  = \(a :: SI) b -> a `isSubsetOf` b .<=> a `union` b .== b+        subsetCharCap  = \(a :: SI) b -> a `isSubsetOf` b .<=> a `intersection` b .== a+        subsetCharImpl = \(a :: SI) b -> a `isSubsetOf` b .<=> a `difference` b .== empty+        subsetCharComp = \(a :: SI) b -> a `isSubsetOf` b .<=> complement b `isSubsetOf` complement a+        relCompCup     = \(a :: SI) b c -> c \\ (a `union` b) .== (c \\ a) `intersection` (c \\ b)+        relCompCap     = \(a :: SI) b c -> c \\ (a `intersection` b) .== (c \\ a) `union` (c \\ b)+        relCompCapCup  = \(a :: SI) b c -> c \\ (b \\ a) .== (a `intersection` c) `union` (c \\ b)+        relCompCapCap  = \(a :: SI) b c -> (b \\ a) `intersection` c .== (b `intersection` c) \\ a+        relCompCapCap2 = \(a :: SI) b c -> (b \\ a) `intersection` c .== b `intersection` (c \\ a)+        relCompCupCup  = \(a :: SI) b c -> (b \\ a) `union` c .== (b `union` c) \\ (a \\ c)+        relCompIdent   = \(a :: SI) -> a \\ a .== empty+        relCompUnitL   = \(a :: SI) -> empty \\ a .== empty+        relCompUnitR   = \(a :: SI) -> empty \\ empty .== a+        relCompCompInt = \(a :: SI) b -> b \\ a .== complement a `intersection` b+        relCompCompUni = \(a :: SI) b -> complement (b \\ a) .== a `union` complement b+        relCompComp    = \(a :: SI) -> full \\ a .== complement a+        relCompFull    = \(a :: SI) -> a \\ full .== empty+        distSubset1    = \(a :: SI) b c -> a `isSubsetOf` (b `union` c) .=> a `isSubsetOf` b .&& a `isSubsetOf` c+        distSubset2    = \(a :: SI) b c -> (b `intersection` c) `isSubsetOf` a .=> b `isSubsetOf` a .&& c `isSubsetOf` a
+ SBVBenchSuite/BenchSuite/Misc/SoftConstrain.hs view
@@ -0,0 +1,37 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.Misc.SoftConstrain+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.Misc.SoftConstrain+-----------------------------------------------------------------------------++{-# LANGUAGE OverloadedStrings #-}++{-# OPTIONS_GHC -Wall -Werror #-}++module BenchSuite.Misc.SoftConstrain(benchmarks) where++import Data.SBV+import BenchSuite.Bench.Bench+++-- benchmark suite+benchmarks :: Runner+benchmarks =  run "SoftConstrain" softC+  where softC = do x <- sString "x"+                   y <- sString "y"++                   constrain $ x .== "x-must-really-be-hello"+                   constrain $ y ./= "y-can-be-anything-but-hello"++                   -- Now add soft-constraints to indicate our preference+                   -- for what these variables should be:+                   softConstrain $ x .== "default-x-value"+                   softConstrain $ y .== "default-y-value"++                   return sTrue
+ SBVBenchSuite/BenchSuite/Misc/Tuple.hs view
@@ -0,0 +1,24 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.Misc.Tuple+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.Misc.Tuple+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror #-}++module BenchSuite.Misc.Tuple(benchmarks) where++import Documentation.SBV.Examples.Misc.Tuple++import BenchSuite.Bench.Bench+++-- benchmark suite+benchmarks :: Runner+benchmarks =  runIO "Tuple" example
+ SBVBenchSuite/BenchSuite/Optimization/Enumerate.hs view
@@ -0,0 +1,28 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.Optimization.Enumerate+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.Optimization.Enumerate+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror #-}++module BenchSuite.Optimization.Enumerate(benchmarks) where++import Documentation.SBV.Examples.Optimization.Enumerate+import BenchSuite.Bench.Bench as B++import BenchSuite.Optimization.Instances()++-- benchmark suite+benchmarks :: Runner+benchmarks = rGroup+  [ runIO "Enumerate.AlmostWeekend"    almostWeekend+  , runIO "Enumerate.WeekendJustOver"  weekendJustOver+  , runIO "Enumerate.firstWeekend"     firstWeekend+  ]
+ SBVBenchSuite/BenchSuite/Optimization/ExtField.hs view
@@ -0,0 +1,26 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.Optimization.ExtField+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.Optimization.ExtField+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror #-}++module BenchSuite.Optimization.ExtField(benchmarks) where++import Documentation.SBV.Examples.Optimization.ExtField+import BenchSuite.Bench.Bench as B+import BenchSuite.Optimization.Instances()++import Data.SBV+++-- benchmark suite+benchmarks :: Runner+benchmarks = run "ExtField.problem" problem `using` runner (flip optimizeWith Lexicographic)
+ SBVBenchSuite/BenchSuite/Optimization/Instances.hs view
@@ -0,0 +1,23 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.Optimization.Instance+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Helper file to provide common orphaned instances for Optimization benchmarks+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror -fno-warn-orphans #-}++module BenchSuite.Optimization.Instances where++import Data.SBV++import Control.DeepSeq+++-- | orphaned instance for benchmarks+instance NFData OptimizeResult where rnf x = seq x ()
+ SBVBenchSuite/BenchSuite/Optimization/LinearOpt.hs view
@@ -0,0 +1,26 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.Optimization.LinearOpt+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.Optimization.LinearOpt+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror #-}++module BenchSuite.Optimization.LinearOpt(benchmarks) where++import Documentation.SBV.Examples.Optimization.LinearOpt+import BenchSuite.Bench.Bench as B+import BenchSuite.Optimization.Instances()++import Data.SBV+++-- benchmark suite+benchmarks :: Runner+benchmarks = run "LinearOpt.problem" problem `using` runner (flip optimizeWith Lexicographic)
+ SBVBenchSuite/BenchSuite/Optimization/Production.hs view
@@ -0,0 +1,26 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.Optimization.Production+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.Optimization.Production+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror #-}++module BenchSuite.Optimization.Production(benchmarks) where++import Documentation.SBV.Examples.Optimization.Production+import BenchSuite.Bench.Bench as B+import BenchSuite.Optimization.Instances()++import Data.SBV+++-- benchmark suite+benchmarks :: Runner+benchmarks = run "Production.production" production `using` runner (flip optimizeWith Lexicographic)
+ SBVBenchSuite/BenchSuite/Optimization/VM.hs view
@@ -0,0 +1,26 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.Optimization.VM+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.Optimization.VM+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror #-}++module BenchSuite.Optimization.VM(benchmarks) where++import Documentation.SBV.Examples.Optimization.VM+import BenchSuite.Bench.Bench as B+import BenchSuite.Optimization.Instances()++import Data.SBV+++-- benchmark suite+benchmarks :: Runner+benchmarks = run "VM.allocate" allocate `using` runner (flip optimizeWith Lexicographic)
− SBVBenchSuite/BenchSuite/Overhead/SBVOverhead.hs 
@@ -1,208 +0,0 @@--------------------------------------------------------------------------------- |--- Module    : BenchSuite.Batch.SBVOverhead--- Copyright : (c) Jeffrey Young--- License   : BSD3--- Maintainer: erkokl@gmail.com--- Stability : experimental------ Assessing the overhead of calling solving examples via sbv vs individual solvers--------------------------------------------------------------------------------{-# OPTIONS_GHC -Wall -Werror -fno-warn-orphans #-}-{-# LANGUAGE CPP                       #-}-{-# LANGUAGE ExistentialQuantification #-}-{-# LANGUAGE FlexibleContexts          #-}-{-# LANGUAGE FlexibleInstances         #-}-{-# LANGUAGE GADTs                     #-}-{-# LANGUAGE RankNTypes                #-}-{-# LANGUAGE RecordWildCards           #-}-{-# LANGUAGE ScopedTypeVariables       #-}--module BenchSuite.Overhead.SBVOverhead-  ( runner-  , runner'-  , runnerWith-  , rGroup-  , mkOverheadBenchMark-  , onConfig-  , onDesc-  , setRunner-  , onProblem-  , Runner(..)-  , using-  ) where--import           Control.DeepSeq         (NFData (..), rwhnf)-import           System.Directory        (getCurrentDirectory)-import           System.IO--import           Criterion.Main--import qualified System.Process          as P-import qualified Utils.SBVBenchFramework as U---- | The type of the problem to benchmark. This allows us to operate on Runners--- as values themselves yet still have a unified interface with criterion.-data Problem = forall a . U.Provable a => Problem a---- | Similarly to Problem, BenchResult is boilerplate for a nice api-data BenchResult = forall a . (Show a, NFData a) => BenchResult a---- | A bench unit is a solver and a problem that represents an input problem--- for the solver to solve-type BenchUnit = (U.SMTConfig, FilePath)---- | A runner is anything that allows the solver to solve, such as:--- 'Data.SBV.proveWith' or 'Data.SBV.satWith'. We utilize existential types to--- lose type information and create a unified interface with criterion. We--- require a runner in order to generate a 'Data.SBV.transcript' and then to run--- the actual benchmark. We bundle this redundantly into a record so that the--- benchmarks can be defined in each respective module, with the run function--- that makes sense for that problem, and then redefined in 'SBVBench'. This is--- useful because problems that require 'Data.SBV.allSatWith' can lead to a lot--- of variance in the benchmarking data. Single benchmark runners like--- 'Data.SBV.satWith' and 'Data.SBV.proveWith' work best.-data RunnerI = RunnerI { run         :: (U.SMTConfig -> Problem -> IO BenchResult)-                       , config      :: U.SMTConfig-                       , description :: String-                       , problem     :: Problem-}---- | GADT to allow arbritrary nesting of runners. This copies criterion's design--- so that we don't have to separate out runners that run a single benchmark--- from runners that need to run several benchmarks-data Runner where-  Runner :: RunnerI -> Runner           -- ^ a single run-  RunnerGroup :: [Runner] -> Runner     -- ^ a group of runs---- | Convenience boilerplate functions, simply avoiding a lens dependency-using :: Runner -> (Runner -> Runner) -> Runner-using = flip ($)--setRunner :: (Show c, NFData c) =>-  (forall a. U.Provable a => U.SMTConfig -> a -> IO c) -> Runner -> Runner-setRunner r' (Runner r@RunnerI{..}) = Runner $ r{run = toRun r'}-setRunner r' (RunnerGroup rs)       = RunnerGroup $ setRunner r' <$> rs--toRun :: (Show c, NFData c) =>-  (forall a. U.Provable a => U.SMTConfig -> a -> IO c)-  -> U.SMTConfig-  -> Problem-  -> IO BenchResult-toRun f c p = BenchResult <$> helper p-  -- simpler to helper in onProblem, this is lmap from profunctor land, i.e., we-  -- curry with a config, then change the runner function from (a -> IO c), to-  -- (Problem -> IO c)-  where helper (Problem a) = f c a--onConfig :: (U.SMTConfig -> U.SMTConfig) -> RunnerI -> RunnerI-onConfig f r@RunnerI{..} = r{config = f config}--onDesc :: (String -> String) -> RunnerI -> RunnerI-onDesc f r@RunnerI{..} = r{description = f description}--onProblem :: (forall a. a -> a) -> RunnerI -> RunnerI-onProblem f r@RunnerI{..} = r{problem = (helper problem)}-  where-    -- helper function to avoid profunctor dependency, this is simply fmap, or-    -- rmap for profunctor land-    helper :: Problem -> Problem-    helper (Problem p) = Problem $ f p----- | Filepath to /dev/null-devNull :: FilePath-#ifndef WINDOWS-devNull = "/dev/null"-#else-devNull = "NUL"-#endif---- | to bench a solver without interfacing through SBV we call transcript to--- have SBV generate the input file for the solver and then create a process to--- initiate execution on the solver. Note that we redirect stdout to /dev/devNull--- or NUL on windows-runStandaloneSolver :: BenchUnit -> IO ()-runStandaloneSolver (slvr, fname) =-  withFile devNull WriteMode $-  (\h -> do (_,_,_,ph) <- P.createProcess (P.shell command){P.std_out = P.UseHandle h}-            _ <- P.waitForProcess ph-            return ())-  where command = U.mkExecString slvr fname---- | Given a file name, a solver config, and a problem to solve, create an--- environment for the criterion benchmark by generating a transcript file-standaloneEnv :: RunnerI -> IO FilePath -> IO BenchUnit-standaloneEnv RunnerI{..} f = f >>= go problem-  where-    -- generate a transcript for the unit-    go p file = do pwd <- getCurrentDirectory-                   let fPath = mconcat [pwd,"/",file]-                   _ <- run config{U.transcript = Just fPath} p >> return ()-                   return (config,fPath)---- | Cleanup the environment created by criterion by removing the transcript--- file used to run the standalone solver-standaloneCleanup :: BenchUnit -> IO ()-standaloneCleanup (_,fPath) =  P.callCommand $ "rm " ++ fPath---- | To construct a benchmark to test SBV's overhead we setup an environment--- with criterion where a symbolic computation is emitted to a transcript file.--- To test the solver without respect to SBV (standalone) we pass the transcript--- file to the solver using the same primitives SBV does. Not that mkFileName--- generates a random filename that is removed at the end of the benchmark. This--- function exposes the solver and the solve interface in case the user would--- like to benchmark with something other than 'Data.SBV.z3' and so that we can--- benchmark all solving variants, e.g., 'Data.SBV.proveWith',--- 'Data.SBV.satWith', 'Data.SBV.allProveWith' etc.-mkOverheadBenchMark' :: RunnerI -> Benchmark-mkOverheadBenchMark' r@RunnerI{..} =-  envWithCleanup-  (standaloneEnv r U.mkFileName)-  standaloneCleanup $-  \ ~unit ->-    bgroup description [ bench "standalone" $ nfIO $ runStandaloneSolver unit-                       -- notice for sbv benchmark; we pull the solver out of unit and-                       -- use the input problem not the transcript in the unit-                       , bench "sbv"        $ nfIO $ run (fst unit) problem-                       ]--mkOverheadBenchMark :: Runner -> Benchmark-mkOverheadBenchMark (Runner r@RunnerI{..}) = mkOverheadBenchMark' r-mkOverheadBenchMark (RunnerGroup rs)       = bgroup "" $ -- leave the description close to the benchmark/problem definition-                                             mkOverheadBenchMark <$> rs---- | This is just a wrapper around the RunnerI constructor and serves as the main--- entry point to make a runner for a user in case they need something custom.-runner' :: (NFData b, Show b) =>-  (forall a. U.Provable a => U.SMTConfig -> a -> IO b)-  -> U.SMTConfig-  -> String-  -> Problem-  -> Runner-runner' r config description problem = Runner $ RunnerI{..}-  where run = toRun r---- | Convenience function for creating benchmarks that exposes a configuration-runnerWith :: U.Provable a => U.SMTConfig -> String -> a -> Runner-runnerWith c d p = runner' U.satWith c d (Problem p)---- | Main entry point for simple benchmarks. See 'mkRunner'' or 'mkRunnerWith'--- for versions of this function that allows custom inputs. If you have some use--- case that is not considered then you can simply overload the record fields.-runner :: U.Provable a => String -> a -> Runner-runner d p = runnerWith U.z3 d p `using` setRunner U.satWith---- | create a runner group. Useful for benchmarks that need to run several--- benchmarks. See 'BenchSuite.Puzzles.NQueens' for an example.-rGroup :: [Runner] -> Runner-rGroup = RunnerGroup---- | Orphaned instances just for benchmarking-instance NFData U.AllSatResult where-  rnf (U.AllSatResult (a, b, c, results)) =-    rnf a `seq` rnf b `seq` rnf c `seq` rwhnf results---- | Unwrap the existential type to make criterion happy-instance NFData BenchResult where rnf (BenchResult a) = rnf a
+ SBVBenchSuite/BenchSuite/ProofTools/BMC.hs view
@@ -0,0 +1,30 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.ProofTools.BMC+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.ProofTools.BMC+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror -fno-warn-orphans #-}++module BenchSuite.ProofTools.BMC(benchmarks) where++import Control.DeepSeq+import Documentation.SBV.Examples.ProofTools.BMC++import BenchSuite.Bench.Bench as B++-- benchmark suite+benchmarks :: Runner+benchmarks = rGroup+  [ runIO "ex1" ex1+  , runIO "ex2" ex2+  ]+++instance NFData a => NFData (S a) where rnf a = seq a ()
+ SBVBenchSuite/BenchSuite/ProofTools/Fibonacci.hs view
@@ -0,0 +1,30 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.ProofTools.Fibonacci+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.ProofTools.Fibonacci+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror -fno-warn-orphans #-}++module BenchSuite.ProofTools.Fibonacci(benchmarks) where++import Control.DeepSeq++import Data.SBV.Tools.Induction+import Documentation.SBV.Examples.ProofTools.Fibonacci++import BenchSuite.Bench.Bench as B++-- benchmark suite+benchmarks :: Runner+benchmarks =  runIO "Correctness" fibCorrect+++instance NFData a => NFData (S a)               where rnf a = seq a ()+instance NFData a => NFData (InductionResult a) where rnf a = seq a ()
+ SBVBenchSuite/BenchSuite/ProofTools/Strengthen.hs view
@@ -0,0 +1,36 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.ProofTools.Strengthen+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.ProofTools.Strengthen+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror -fno-warn-orphans #-}++module BenchSuite.ProofTools.Strengthen(benchmarks) where++import Control.DeepSeq++import Data.SBV.Tools.Induction+import Documentation.SBV.Examples.ProofTools.Strengthen++import BenchSuite.Bench.Bench as B++-- benchmark suite+benchmarks :: Runner+benchmarks = rGroup+  [ runIO "ex1" ex1+  , runIO "ex2" ex2+  , runIO "ex3" ex3+  , runIO "ex4" ex4+  , runIO "ex5" ex5+  , runIO "ex6" ex6+  ]++instance NFData a => NFData (S a)               where rnf a = seq a ()+instance NFData a => NFData (InductionResult a) where rnf a = seq a ()
+ SBVBenchSuite/BenchSuite/ProofTools/Sum.hs view
@@ -0,0 +1,29 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.ProofTools.Sum+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.ProofTools.Sum+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror -fno-warn-orphans #-}++module BenchSuite.ProofTools.Sum(benchmarks) where++import Control.DeepSeq++import Data.SBV.Tools.Induction+import Documentation.SBV.Examples.ProofTools.Sum++import BenchSuite.Bench.Bench as B++-- benchmark suite+benchmarks :: Runner+benchmarks = runIO "Correctness" sumCorrect++instance NFData a => NFData (S a)+instance NFData a => NFData (InductionResult a) where rnf a = seq a ()
SBVBenchSuite/BenchSuite/Puzzles/Birthday.hs view
@@ -16,10 +16,10 @@  import Documentation.SBV.Examples.Puzzles.Birthday +import BenchSuite.Bench.Bench as S import Utils.SBVBenchFramework-import BenchSuite.Overhead.SBVOverhead   -- benchmark suite benchmarks :: Runner-benchmarks = runner "Birthday" puzzle `using` setRunner allSatWith+benchmarks = S.run "Birthday" puzzle `using` runner allSatWith
SBVBenchSuite/BenchSuite/Puzzles/Coins.hs view
@@ -17,12 +17,12 @@ import Documentation.SBV.Examples.Puzzles.Coins  import Utils.SBVBenchFramework-import BenchSuite.Overhead.SBVOverhead+import BenchSuite.Bench.Bench as S   -- benchmark suite benchmarks :: Runner-benchmarks = runner "Coins" coinsPgm+benchmarks = S.run "Coins" coinsPgm   where coinsPgm = do cs <- mapM mkCoin [1..6]                       mapM_ constrain [c s | s <- combinations cs, length s >= 2, c <- [c1, c2, c3, c4, c5, c6]]                       constrain $ sAnd $ zipWith (.>=) cs (tail cs)
SBVBenchSuite/BenchSuite/Puzzles/Counts.hs view
@@ -17,11 +17,11 @@ import Documentation.SBV.Examples.Puzzles.Counts  import Utils.SBVBenchFramework-import BenchSuite.Overhead.SBVOverhead+import BenchSuite.Bench.Bench as S   -- benchmark suite benchmarks :: Runner-benchmarks = runner "Counts" countPgm `using` setRunner allSatWith+benchmarks = S.run "Counts" countPgm `using` runner allSatWith  where countPgm = forAll_ puzzle' >>= return -- avoiding 'output' here again        puzzle' d0 d1 d2 d3 d4 d5 d6 d7 d8 d9 = puzzle [d0, d1, d2, d3, d4, d5, d6, d7, d8, d9]
SBVBenchSuite/BenchSuite/Puzzles/DogCatMouse.hs view
@@ -15,12 +15,12 @@ module BenchSuite.Puzzles.DogCatMouse(benchmarks) where  import Utils.SBVBenchFramework-import BenchSuite.Overhead.SBVOverhead+import BenchSuite.Bench.Bench as S   -- benchmark suite benchmarks :: Runner-benchmarks = runner "DogCatMouse" p `using` setRunner allSatWith+benchmarks = S.run "DogCatMouse" p `using` runner allSatWith   where p = do [dog, cat, mouse] <- sIntegers ["dog", "cat", "mouse"]                solve [ dog   .>= 1                                   -- at least one dog                      , cat   .>= 1                                   -- at least one cat
SBVBenchSuite/BenchSuite/Puzzles/Euler185.hs view
@@ -17,9 +17,9 @@ import Documentation.SBV.Examples.Puzzles.Euler185  import Utils.SBVBenchFramework-import BenchSuite.Overhead.SBVOverhead+import BenchSuite.Bench.Bench as S   -- benchmark suite benchmarks :: Runner-benchmarks = runner "Euler185" euler185 `using` setRunner allSatWith+benchmarks = S.run "Euler185" euler185 `using` runner allSatWith
SBVBenchSuite/BenchSuite/Puzzles/Garden.hs view
@@ -19,10 +19,10 @@ import Documentation.SBV.Examples.Puzzles.Garden  import Utils.SBVBenchFramework-import BenchSuite.Overhead.SBVOverhead+import BenchSuite.Bench.Bench as S   -- benchmark suite-benchmarks :: Runner -benchmarks = runnerWith s "Garden" puzzle `using` setRunner allSatWith+benchmarks :: Runner+benchmarks = S.runWith s "Garden" puzzle `using` runner allSatWith   where s = z3{satTrackUFs = False, isNonModelVar = ("_modelIgnore" `isSuffixOf`)}
SBVBenchSuite/BenchSuite/Puzzles/LadyAndTigers.hs view
@@ -16,12 +16,12 @@   import Utils.SBVBenchFramework-import BenchSuite.Overhead.SBVOverhead+import BenchSuite.Bench.Bench as S   -- benchmark suite benchmarks :: Runner-benchmarks = runner "Puzzles.LadyAndTigers" p `using` setRunner allSatWith+benchmarks = S.run "Puzzles.LadyAndTigers" p `using` runner allSatWith   where p = do            -- One boolean for each of the correctness of the signs
SBVBenchSuite/BenchSuite/Puzzles/MagicSquare.hs view
@@ -17,14 +17,14 @@ import Documentation.SBV.Examples.Puzzles.MagicSquare  import Utils.SBVBenchFramework-import BenchSuite.Overhead.SBVOverhead+import BenchSuite.Bench.Bench as S   -- benchmark suite benchmarks :: Runner benchmarks = rGroup-  [ runner "MagicSquare.magic 2" (mkMagic 2) `using` setRunner allSatWith-  , runner "MagicSquare.magic 3" (mkMagic 3) `using` setRunner allSatWith+  [ S.run "MagicSquare.magic 2" (mkMagic 2) `using` runner allSatWith+  , S.run "MagicSquare.magic 3" (mkMagic 3) `using` runner allSatWith   ]  mkMagic :: Int -> Symbolic SBool
SBVBenchSuite/BenchSuite/Puzzles/NQueens.hs view
@@ -17,20 +17,20 @@ import Documentation.SBV.Examples.Puzzles.NQueens  import Utils.SBVBenchFramework-import BenchSuite.Overhead.SBVOverhead+import BenchSuite.Bench.Bench as S   -- benchmark suite benchmarks :: Runner benchmarks = rGroup-  [ runner "NQueens.NQueens 1" (mkQueens 1) `using` setRunner allSatWith-  , runner "NQueens.NQueens 2" (mkQueens 2) `using` setRunner allSatWith-  , runner "NQueens.NQueens 3" (mkQueens 3) `using` setRunner allSatWith-  , runner "NQueens.NQueens 4" (mkQueens 4) `using` setRunner allSatWith-  , runner "NQueens.NQueens 5" (mkQueens 5) `using` setRunner allSatWith-  , runner "NQueens.NQueens 6" (mkQueens 6) `using` setRunner allSatWith-  , runner "NQueens.NQueens 7" (mkQueens 7) `using` setRunner allSatWith-  , runner "NQueens.NQueens 8" (mkQueens 8) `using` setRunner allSatWith+  [ S.run "NQueens.NQueens 1" (mkQueens 1) `using` runner allSatWith+  , S.run "NQueens.NQueens 2" (mkQueens 2) `using` runner allSatWith+  , S.run "NQueens.NQueens 3" (mkQueens 3) `using` runner allSatWith+  , S.run "NQueens.NQueens 4" (mkQueens 4) `using` runner allSatWith+  , S.run "NQueens.NQueens 5" (mkQueens 5) `using` runner allSatWith+  , S.run "NQueens.NQueens 6" (mkQueens 6) `using` runner allSatWith+  , S.run "NQueens.NQueens 7" (mkQueens 7) `using` runner allSatWith+  , S.run "NQueens.NQueens 8" (mkQueens 8) `using` runner allSatWith   ]  mkQueens :: Int -> Symbolic SBool
SBVBenchSuite/BenchSuite/Puzzles/SendMoreMoney.hs view
@@ -16,12 +16,12 @@   import Utils.SBVBenchFramework-import BenchSuite.Overhead.SBVOverhead+import BenchSuite.Bench.Bench as S   -- benchmark suite benchmarks :: Runner-benchmarks = runner "Puzzles.SendMoreMoney" p `using` setRunner allSatWith+benchmarks = S.run "Puzzles.SendMoreMoney" p `using` runner allSatWith   where p = do           ds@[s,e,n,d,m,o,r,y] <- mapM sInteger ["s", "e", "n", "d", "m", "o", "r", "y"]           let isDigit x = x .>= 0 .&& x .<= 9
SBVBenchSuite/BenchSuite/Puzzles/Sudoku.hs view
@@ -17,13 +17,13 @@ import Documentation.SBV.Examples.Puzzles.Sudoku  import Utils.SBVBenchFramework-import BenchSuite.Overhead.SBVOverhead+import BenchSuite.Bench.Bench as S   -- benchmark suite benchmarks :: Runner benchmarks = rGroup-    [ runner ("sudoku " ++ show n) (checkPuzzle s) `using` setRunner allSatWith+    [ S.run ("sudoku " ++ show n) (checkPuzzle s) `using` runner allSatWith        | (n, s) <-            zip              [(0::Int)..]
SBVBenchSuite/BenchSuite/Puzzles/U2Bridge.hs view
@@ -17,17 +17,17 @@ import Documentation.SBV.Examples.Puzzles.U2Bridge  import Utils.SBVBenchFramework-import BenchSuite.Overhead.SBVOverhead+import BenchSuite.Bench.Bench as S   -- benchmark suite benchmarks :: Runner benchmarks = rGroup-  [ runner "U2Bridge_cnt1" (count 1) `using` setRunner allSatWith-  , runner "U2Bridge_cnt2" (count 2) `using` setRunner allSatWith-  , runner "U2Bridge_cnt3" (count 3) `using` setRunner allSatWith-  , runner "U2Bridge_cnt4" (count 4) `using` setRunner allSatWith-  , runner "U2Bridge_cnt6" (count 6) `using` setRunner allSatWith+  [ S.run "U2Bridge_cnt1" (count 1) `using` runner allSatWith+  , S.run "U2Bridge_cnt2" (count 2) `using` runner allSatWith+  , S.run "U2Bridge_cnt3" (count 3) `using` runner allSatWith+  , S.run "U2Bridge_cnt4" (count 4) `using` runner allSatWith+  , S.run "U2Bridge_cnt6" (count 6) `using` runner allSatWith   ]   where     act     = do b <- exists_; p1 <- exists_; p2 <- exists_; return (b, p1, p2)
+ SBVBenchSuite/BenchSuite/Queries/AllSat.hs view
@@ -0,0 +1,22 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.Queries.AllSat+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.Queries.AllSat+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror #-}++module BenchSuite.Queries.AllSat(benchmarks) where++import Documentation.SBV.Examples.Queries.AllSat++import BenchSuite.Bench.Bench++benchmarks :: Runner+benchmarks = runIO "AllSat" demo
+ SBVBenchSuite/BenchSuite/Queries/CaseSplit.hs view
@@ -0,0 +1,24 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.Queries.CaseSplit+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.Queries.CaseSplit+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror #-}++module BenchSuite.Queries.CaseSplit(benchmarks) where++import Documentation.SBV.Examples.Queries.CaseSplit++import BenchSuite.Bench.Bench++benchmarks :: Runner+benchmarks = rGroup [ runIO "CaseSplit.1" csDemo1+                    , runIO "CaseSplit.2" csDemo2+                    ]
+ SBVBenchSuite/BenchSuite/Queries/Concurrency.hs view
@@ -0,0 +1,26 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.Queries.Concurrency+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.Queries.Concurrency+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror #-}++module BenchSuite.Queries.Concurrency(benchmarks) where++import Documentation.SBV.Examples.Queries.Concurrency++import BenchSuite.Bench.Bench++-- these benchmarks won't run in multithreaded mode. The benchmark target is not+-- build as -threaded+benchmarks :: Runner+benchmarks = rGroup [ runIO "Concurrency.demo"          demo+                    , runIO "Concurrency.demoDependent" demoDependent+                    ]
+ SBVBenchSuite/BenchSuite/Queries/Enums.hs view
@@ -0,0 +1,27 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.Queries.Enums+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.Queries.Enums+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror -fno-warn-orphans #-}++module BenchSuite.Queries.Enums(benchmarks) where++import Documentation.SBV.Examples.Queries.Enums++import Control.DeepSeq+import BenchSuite.Bench.Bench++-- | orphaned instance for benchmarks+instance NFData Day where rnf x = seq x ()++benchmarks :: Runner+benchmarks = rGroup [ runIO "Enums.findDays" findDays+                    ]
+ SBVBenchSuite/BenchSuite/Queries/FourFours.hs view
@@ -0,0 +1,22 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.Queries.FourFours+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.Queries.FourFours+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror #-}++module BenchSuite.Queries.FourFours(benchmarks) where++import Documentation.SBV.Examples.Queries.FourFours++import BenchSuite.Bench.Bench++benchmarks :: Runner+benchmarks =  runIO "FourFours.puzzle" puzzle
+ SBVBenchSuite/BenchSuite/Queries/GuessNumber.hs view
@@ -0,0 +1,22 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.Queries.GuessNumber+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.Queries.GuessNumber+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror -fno-warn-orphans #-}++module BenchSuite.Queries.GuessNumber(benchmarks) where++import Documentation.SBV.Examples.Queries.GuessNumber++import BenchSuite.Bench.Bench++benchmarks :: Runner+benchmarks =  runIO "GuessNumber.play" play
+ SBVBenchSuite/BenchSuite/Queries/Interpolants.hs view
@@ -0,0 +1,24 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.Queries.Interpolants+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.Queries.Interpolants+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror #-}++module BenchSuite.Queries.Interpolants(benchmarks) where++import Documentation.SBV.Examples.Queries.Interpolants++import BenchSuite.Bench.Bench++import Data.SBV++benchmarks :: Runner+benchmarks =  runIO "Interpolants.evenOdd" $ runSMT evenOdd
+ SBVBenchSuite/BenchSuite/Queries/UnsatCore.hs view
@@ -0,0 +1,22 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.Queries.UnsatCore+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.Queries.UnsatCore+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror #-}++module BenchSuite.Queries.UnsatCore(benchmarks) where++import Documentation.SBV.Examples.Queries.UnsatCore++import BenchSuite.Bench.Bench++benchmarks :: Runner+benchmarks =  runIO "UnsatCore.ucCore" ucCore
+ SBVBenchSuite/BenchSuite/Strings/RegexCrossword.hs view
@@ -0,0 +1,27 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.Strings.RegexCrossword+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.Strings.RegexCrossword+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror #-}++module BenchSuite.Strings.RegexCrossword(benchmarks) where++import Documentation.SBV.Examples.Strings.RegexCrossword++import BenchSuite.Bench.Bench++-- benchmark suite+benchmarks :: Runner+benchmarks = rGroup+             [ runIO "puzzle1" $ puzzle1+             , runIO "puzzle2" $ puzzle2+             , runIO "puzzle3" $ puzzle3+             ]
+ SBVBenchSuite/BenchSuite/Strings/SQLInjection.hs view
@@ -0,0 +1,24 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.Strings.SQLInjection+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.Strings.SQLInjection+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror #-}++module BenchSuite.Strings.SQLInjection(benchmarks) where++import Documentation.SBV.Examples.Strings.SQLInjection+import Data.List++import BenchSuite.Bench.Bench++-- benchmark suite+benchmarks :: Runner+benchmarks =  runIO "FindInjection" $ ("'; DROP TABLE 'users" `Data.List.isSuffixOf`) <$> findInjection exampleProgram
+ SBVBenchSuite/BenchSuite/Transformers/SymbolicEval.hs view
@@ -0,0 +1,30 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.Transformers.SymbolicEval+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.Transformers.SymbolicEval+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror -fno-warn-orphans #-}++module BenchSuite.Transformers.SymbolicEval(benchmarks) where++import Documentation.SBV.Examples.Transformers.SymbolicEval+import Control.DeepSeq++import BenchSuite.Bench.Bench++-- benchmark suite+benchmarks :: Runner+benchmarks =  rGroup+              [ runIO "Example.1" ex1+              , runIO "Example.2" ex2+              , runIO "Example.3" ex3+              ]++instance NFData CheckResult where rnf x = seq x ()
+ SBVBenchSuite/BenchSuite/Uninterpreted/AUF.hs view
@@ -0,0 +1,35 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.Uninterpreted.AUF+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.Uninterpreted.AUF+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror -fno-warn-orphans #-}+{-# LANGUAGE ScopedTypeVariables #-}++module BenchSuite.Uninterpreted.AUF(benchmarks) where++import Documentation.SBV.Examples.Uninterpreted.AUF+import Data.SBV++import BenchSuite.Bench.Bench++benchmarks :: Runner+benchmarks = rGroup+  [ run "SArray" array `using` runner proveWith+  , run "SFunArray" funArray `using` runner proveWith+  ]+  where array = do x <- free "x"+                   y <- free "y"+                   a :: SArray Word32 Word32 <- newArray_ Nothing+                   return $ thm x y a+        funArray = do x <- free "x"+                      y <- free "y"+                      a :: SFunArray Word32 Word32 <- newArray_ Nothing+                      return $ thm x y a
+ SBVBenchSuite/BenchSuite/Uninterpreted/Deduce.hs view
@@ -0,0 +1,35 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.Uninterpreted.Deduce+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.Uninterpreted.Deduce+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror -fno-warn-orphans #-}+{-# LANGUAGE ScopedTypeVariables #-}++module BenchSuite.Uninterpreted.Deduce(benchmarks) where++import Documentation.SBV.Examples.Uninterpreted.Deduce+import Data.SBV++import Prelude hiding (not, or, and)+import BenchSuite.Bench.Bench++benchmarks :: Runner+benchmarks = rGroup+  [ run "test" t `using` runner proveWith+  ]+  where t = do addAxiom "OR distributes over AND" ax1+               addAxiom "de Morgan"               ax2+               addAxiom "double negation"         ax3+               p <- free "p"+               q <- free "q"+               r <- free "r"+               return $ not (p `or` (q `and` r))+                 .== (not p `and` not q) `or` (not p `and` not r)
+ SBVBenchSuite/BenchSuite/Uninterpreted/Function.hs view
@@ -0,0 +1,25 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.Uninterpreted.Function+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.Uninterpreted.Function+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror #-}++module BenchSuite.Uninterpreted.Function(benchmarks) where++import Documentation.SBV.Examples.Uninterpreted.Function+import Data.SBV++import BenchSuite.Bench.Bench++benchmarks :: Runner+benchmarks = rGroup+  [ run "thmGood" thmGood `using` runner proveWith+  ]
+ SBVBenchSuite/BenchSuite/Uninterpreted/Multiply.hs view
@@ -0,0 +1,38 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.Uninterpreted.Multiply+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.Uninterpreted.Multiply+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror #-}+{-# LANGUAGE ScopedTypeVariables #-}++module BenchSuite.Uninterpreted.Multiply(benchmarks) where++import Documentation.SBV.Examples.Uninterpreted.Multiply+import Data.SBV++import BenchSuite.Bench.Bench++benchmarks :: Runner+benchmarks = rGroup+  [ run "synthMul22" synthMul22 `using` runner satWith+  , run "Correctness" correct `using` runner proveWith+  ]+  where+    mul22_hi :: SBool -> SBool -> SBool -> SBool -> SBool+    mul22_hi a1 a0 b1 b0 = ite ([a1, a0, b1, b0] .== [sFalse, sTrue , sTrue , sFalse]) sTrue+                         $ ite ([a1, a0, b1, b0] .== [sFalse, sTrue , sTrue , sTrue ]) sTrue+                         $ ite ([a1, a0, b1, b0] .== [sTrue , sFalse, sFalse, sTrue ]) sTrue+                         $ ite ([a1, a0, b1, b0] .== [sTrue , sFalse, sTrue , sTrue ]) sTrue+                         $ ite ([a1, a0, b1, b0] .== [sTrue , sTrue , sFalse, sTrue ]) sTrue+                         $ ite ([a1, a0, b1, b0] .== [sTrue , sTrue , sTrue , sFalse]) sTrue+                           sFalse++    correct = \a1 a0 b1 b0 -> mul22_hi a1 a0 b1 b0 .== (a1 .&& b0) .<+> (a0 .&& b1)
+ SBVBenchSuite/BenchSuite/Uninterpreted/Shannon.hs view
@@ -0,0 +1,43 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.Uninterpreted.Shannon+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.Uninterpreted.Shannon+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror #-}+{-# LANGUAGE ScopedTypeVariables #-}++module BenchSuite.Uninterpreted.Shannon(benchmarks) where++import Documentation.SBV.Examples.Uninterpreted.Shannon+import Data.SBV++import BenchSuite.Bench.Bench++benchmarks :: Runner+benchmarks = rGroup+  [ run "shannon"  _shannon  `using` runner proveWith+  , run "shannon2" _shannon2 `using` runner proveWith+  , run "noWiggle" _noWiggle `using` runner proveWith+  , run "univOk"   _univOK   `using` runner proveWith+  , run "existsOk" _existsOK `using` runner proveWith+  ]+  where _shannon  = \x y z -> f x y z .== (x .&& pos f y z .|| sNot x .&& neg f y z)+        _shannon2 = \x y z -> f x y z .== ((x .|| neg f y z) .&& (sNot x .|| pos f y z))+        _noWiggle = \y z -> sNot (f' y z) .<=> pos f y z .== neg f y z+        _univOK   = \y z -> f'' y z .=> pos f y z .&& neg f y z+        _existsOK = \y z -> f''' y z .=> pos f y z .|| neg f y z+++f :: Ternary+f    = uninterpret "f"+f', f'', f''' :: Binary+f'   = derivative f+f''  = universal f+f''' = existential f
+ SBVBenchSuite/BenchSuite/Uninterpreted/Sort.hs view
@@ -0,0 +1,32 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.Uninterpreted.Sort+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.Uninterpreted.Sort+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror #-}++module BenchSuite.Uninterpreted.Sort(benchmarks) where++import Documentation.SBV.Examples.Uninterpreted.Sort+import Data.SBV++import BenchSuite.Bench.Bench++benchmarks :: Runner+benchmarks = rGroup+  [ run "t1" _t1 `using` runner satWith+  , run "r2" _t1 `using` runner satWith+  ]+  where _t1 = do x <- free "x"+                 return $ f x ./= x++        _t2 = do x <- free "x"+                 addAxiom "Q" ["(assert (forall ((x Q) (y Q)) (= x y)))"]+                 return $ f x ./= x
+ SBVBenchSuite/BenchSuite/Uninterpreted/UISortAllSat.hs view
@@ -0,0 +1,23 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.Uninterpreted.UISortAllSat+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.Uninterpreted.UISortAllSat+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror #-}++module BenchSuite.Uninterpreted.UISortAllSat(benchmarks) where++import Documentation.SBV.Examples.Uninterpreted.UISortAllSat+import Data.SBV++import BenchSuite.Bench.Bench++benchmarks :: Runner+benchmarks =  run "genLs" genLs `using` runner allSatWith -- could be expensive
+ SBVBenchSuite/BenchSuite/WeakestPreconditions/Append.hs view
@@ -0,0 +1,28 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.WeakestPreconditions.Append+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.WeakestPreconditions.Append+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror -fno-warn-orphans #-}++module BenchSuite.WeakestPreconditions.Append(benchmarks) where++import Documentation.SBV.Examples.WeakestPreconditions.Append++import Control.DeepSeq+import BenchSuite.Bench.Bench+import BenchSuite.WeakestPreconditions.Instances()+++-- | orphaned instance for benchmarks+instance NFData a => NFData (AppC a) where rnf x = seq x ()++benchmarks :: Runner+benchmarks = runIO "Correctness.Append" correctness
+ SBVBenchSuite/BenchSuite/WeakestPreconditions/Basics.hs view
@@ -0,0 +1,38 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.WeakestPreconditions.Basics+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.WeakestPreconditions.Basics+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -fno-warn-orphans #-}+{-# LANGUAGE NamedFieldPuns #-}++module BenchSuite.WeakestPreconditions.Basics(benchmarks) where++import Documentation.SBV.Examples.WeakestPreconditions.Basics+import Data.SBV+import Data.SBV.Tools.WeakestPreconditions++import Control.DeepSeq+import BenchSuite.Bench.Bench+import BenchSuite.WeakestPreconditions.Instances()++instance NFData a => NFData (IncS a)+++benchmarks :: Runner+benchmarks = rGroup+  [ runIO "Correctness.Basics skip" (correctness Skip Skip)+  , runIO "Correctness.Basics y+1"  (correctness Skip $ Assign $ \st@IncS{y} -> st{y = y+1})+  , runIO "Correctness.Basics x>0"  $ correctness (assert "x > 0" (\st@IncS{x} -> x .> 0)) Skip+  , runIO "Correctness.Basics x>-5" $ correctness (assert "x > -5" (\st@IncS{x} -> x .> -5)) Skip+  , runIO "Correctness.Basics y is even"   $ correctness Skip (assert "y is even" (\st@IncS{y} -> y `sMod` 2 .== 0))+  , runIO "Correctness.Basics y > x"       $ correctness Skip (assert "y > x" (\st@IncS{x, y} -> y .> x))+  , runIO "Correctness.Basics skip-assign" $ correctness Skip (Assign $ \st -> st{x = 10, y = 11})+  ]
+ SBVBenchSuite/BenchSuite/WeakestPreconditions/Fib.hs view
@@ -0,0 +1,32 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.WeakestPreconditions.Fig+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.WeakestPreconditions.Fig+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror -fno-warn-orphans #-}+{-# LANGUAGE NamedFieldPuns #-}++module BenchSuite.WeakestPreconditions.Fib(benchmarks) where++import Documentation.SBV.Examples.WeakestPreconditions.Fib+import Data.SBV.Tools.WeakestPreconditions++import Control.DeepSeq+import BenchSuite.Bench.Bench+import BenchSuite.WeakestPreconditions.Instances()++instance NFData a => NFData (FibS a)+++benchmarks :: Runner+benchmarks = rGroup+  [ runIO "Correctness.Fib" correctness+  , runIO "ImperativeFib" $ traceExecution imperativeFib $ FibS {n = 3, i = 0, k = 0, m = 0}+  ]
+ SBVBenchSuite/BenchSuite/WeakestPreconditions/GCD.hs view
@@ -0,0 +1,32 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.WeakestPreconditions.GCD+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.WeakestPreconditions.GCD+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror -fno-warn-orphans #-}+{-# LANGUAGE NamedFieldPuns #-}++module BenchSuite.WeakestPreconditions.GCD(benchmarks) where++import Documentation.SBV.Examples.WeakestPreconditions.GCD+import Data.SBV.Tools.WeakestPreconditions++import Control.DeepSeq+import BenchSuite.Bench.Bench+import BenchSuite.WeakestPreconditions.Instances()++instance NFData a => NFData (GCDS a)+++benchmarks :: Runner+benchmarks = rGroup+  [ runIO "Correctness.GCD" correctness+  , runIO "ImperativeGCD" $ traceExecution imperativeGCD $ GCDS {x = 14, y = 4, i = 0, j = 0}+  ]
+ SBVBenchSuite/BenchSuite/WeakestPreconditions/Instances.hs view
@@ -0,0 +1,24 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.WeakestPreconditions.Instance+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Helper file to provide common orphaned instances for WeakestPrecondition benchmarks+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror -fno-warn-orphans #-}++module BenchSuite.WeakestPreconditions.Instances where++import Data.SBV.Tools.WeakestPreconditions++import Control.DeepSeq+++-- | orphaned instance for benchmarks+instance NFData a => NFData (ProofResult a) where rnf x = seq x ()+instance NFData a => NFData (Status a) where rnf x = seq x ()
+ SBVBenchSuite/BenchSuite/WeakestPreconditions/IntDiv.hs view
@@ -0,0 +1,28 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.WeakestPreconditions.IntDiv+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.WeakestPreconditions.IntDiv+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror -fno-warn-orphans #-}+{-# LANGUAGE NamedFieldPuns #-}++module BenchSuite.WeakestPreconditions.IntDiv(benchmarks) where++import Documentation.SBV.Examples.WeakestPreconditions.IntDiv++import Control.DeepSeq+import BenchSuite.Bench.Bench+import BenchSuite.WeakestPreconditions.Instances()++instance NFData a => NFData (DivS a)+++benchmarks :: Runner+benchmarks = runIO "Correctness.IntDiv" correctness
+ SBVBenchSuite/BenchSuite/WeakestPreconditions/IntSqrt.hs view
@@ -0,0 +1,28 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.WeakestPreconditions.IntSqrt+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.WeakestPreconditions.IntSqrt+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror -fno-warn-orphans #-}+{-# LANGUAGE NamedFieldPuns #-}++module BenchSuite.WeakestPreconditions.IntSqrt(benchmarks) where++import Documentation.SBV.Examples.WeakestPreconditions.IntSqrt++import Control.DeepSeq+import BenchSuite.Bench.Bench+import BenchSuite.WeakestPreconditions.Instances()++instance NFData a => NFData (SqrtS a)+++benchmarks :: Runner+benchmarks = runIO "Correctness.IntSqrt" correctness
+ SBVBenchSuite/BenchSuite/WeakestPreconditions/Length.hs view
@@ -0,0 +1,28 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.WeakestPreconditions.Length+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.WeakestPreconditions.Length+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror -fno-warn-orphans #-}+{-# LANGUAGE NamedFieldPuns #-}++module BenchSuite.WeakestPreconditions.Length(benchmarks) where++import Documentation.SBV.Examples.WeakestPreconditions.Length++import Control.DeepSeq+import BenchSuite.Bench.Bench+import BenchSuite.WeakestPreconditions.Instances()++instance NFData a => NFData (LenS a)+++benchmarks :: Runner+benchmarks = runIO "Correctness.Length" correctness
+ SBVBenchSuite/BenchSuite/WeakestPreconditions/Sum.hs view
@@ -0,0 +1,45 @@+-----------------------------------------------------------------------------+-- |+-- Module    : BenchSuite.WeakestPreconditions.Sum+-- Copyright : (c) Jeffrey Young+--                 Levent Erkok+-- License   : BSD3+-- Maintainer: erkokl@gmail.com+-- Stability : experimental+--+-- Bench suite for Documentation.SBV.Examples.WeakestPreconditions.Sum+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall -Werror -fno-warn-orphans #-}+{-# LANGUAGE NamedFieldPuns #-}++module BenchSuite.WeakestPreconditions.Sum(benchmarks) where++import Documentation.SBV.Examples.WeakestPreconditions.Sum+import Data.SBV++import Control.DeepSeq+import BenchSuite.Bench.Bench+import BenchSuite.WeakestPreconditions.Instances()++instance NFData a => NFData (SumS a)+++benchmarks :: Runner+benchmarks = rGroup [ runIO "Correctness.Sum.correctInvariant"     $ correctness correctInvariant (Just measure)+                    , runIO "Correctness.Sum.alwaysFalseInvariant" $ correctness alwaysFalseInvariant Nothing+                    , runIO "Correctness.Sum.alwaysTrueInvariant"  $ correctness alwaysTrueInvariant Nothing+                    , runIO "Correctness.Sum.loopInvariant"        $ correctness loopInvariant Nothing+                    , runIO "Correctness.Sum.badMeasure1"          $ correctness badMeasure1Invariant (Just badMeasure1)+                    , runIO "Correctness.Sum.badMeasure2"          $ correctness badMeasure2Invariant (Just badMeasure2)+                    ]+             where+               correctInvariant     SumS{n, i, s} = s .== (i*(i+1)) `sDiv` 2 .&& i .<= n+               measure              SumS{n, i}    = [n - i]+               alwaysFalseInvariant _             = sFalse+               alwaysTrueInvariant  _             =  sTrue+               loopInvariant        SumS{n, i, s} = s .<= i .&& s .== (i*(i+1)) `sDiv` 2 .&& i .<= n+               badMeasure1Invariant SumS{n, i, s} = s .== (i*(i+1)) `sDiv` 2 .&& i .<= n+               badMeasure1          SumS{i}       = [- i]+               badMeasure2Invariant SumS{n, i, s} = s .== (i*(i+1)) `sDiv` 2 .&& i .<= n+               badMeasure2          SumS{n, i}    = [n + i]
SBVBenchSuite/SBVBench.hs view
@@ -2,6 +2,7 @@ -- | -- Module    : SBVBench -- Copyright : (c) Jeffrey Young+--                 Levent Erkok -- License   : BSD3 -- Maintainer: erkokl@gmail.com -- Stability : experimental@@ -11,13 +12,14 @@  module Main where -import           Criterion.Main-import           Criterion.Types                  (Config (..))+import           Gauge.Main+import           Gauge.Main.Options (defaultConfig, Config(..))  import           Utils.SBVBenchFramework -import           BenchSuite.Overhead.SBVOverhead+import           BenchSuite.Bench.Bench +-- | Puzzles import qualified BenchSuite.Puzzles.Birthday import qualified BenchSuite.Puzzles.Coins import qualified BenchSuite.Puzzles.Counts@@ -31,31 +33,135 @@ import qualified BenchSuite.Puzzles.Sudoku import qualified BenchSuite.Puzzles.U2Bridge +-- | BitPrecise+import qualified BenchSuite.BitPrecise.BitTricks+import qualified BenchSuite.BitPrecise.BrokenSearch+import qualified BenchSuite.BitPrecise.Legato+import qualified BenchSuite.BitPrecise.MergeSort+import qualified BenchSuite.BitPrecise.MultMask+import qualified BenchSuite.BitPrecise.PrefixSum++-- | Queries+import qualified BenchSuite.Queries.AllSat+import qualified BenchSuite.Queries.CaseSplit+import qualified BenchSuite.Queries.Concurrency+import qualified BenchSuite.Queries.Enums+import qualified BenchSuite.Queries.FourFours+import qualified BenchSuite.Queries.GuessNumber+import qualified BenchSuite.Queries.Interpolants+import qualified BenchSuite.Queries.UnsatCore++-- | Weakest Preconditions+import qualified BenchSuite.WeakestPreconditions.Append+import qualified BenchSuite.WeakestPreconditions.Basics+import qualified BenchSuite.WeakestPreconditions.Fib+import qualified BenchSuite.WeakestPreconditions.GCD+import qualified BenchSuite.WeakestPreconditions.IntDiv+import qualified BenchSuite.WeakestPreconditions.IntSqrt+import qualified BenchSuite.WeakestPreconditions.Length+import qualified BenchSuite.WeakestPreconditions.Sum++-- | Optimization+import qualified BenchSuite.Optimization.Enumerate+import qualified BenchSuite.Optimization.ExtField+import qualified BenchSuite.Optimization.LinearOpt+import qualified BenchSuite.Optimization.Production+import qualified BenchSuite.Optimization.VM++-- | Uninterpreted+import qualified BenchSuite.Uninterpreted.AUF+import qualified BenchSuite.Uninterpreted.Deduce+import qualified BenchSuite.Uninterpreted.Function+import qualified BenchSuite.Uninterpreted.Multiply+import qualified BenchSuite.Uninterpreted.Shannon+import qualified BenchSuite.Uninterpreted.Sort+import qualified BenchSuite.Uninterpreted.UISortAllSat++-- | Proof Tools+import qualified BenchSuite.ProofTools.BMC+import qualified BenchSuite.ProofTools.Fibonacci+import qualified BenchSuite.ProofTools.Strengthen+import qualified BenchSuite.ProofTools.Sum++-- | Code Generation+import qualified BenchSuite.CodeGeneration.AddSub+import qualified BenchSuite.CodeGeneration.CRC_USB5+import qualified BenchSuite.CodeGeneration.Fibonacci+import qualified BenchSuite.CodeGeneration.GCD+import qualified BenchSuite.CodeGeneration.PopulationCount+import qualified BenchSuite.CodeGeneration.Uninterpreted++-- | Crypto+import qualified BenchSuite.Crypto.AES+import qualified BenchSuite.Crypto.RC4+import qualified BenchSuite.Crypto.SHA++-- | Miscellaneous+import qualified BenchSuite.Misc.Auxiliary+import qualified BenchSuite.Misc.Enumerate+import qualified BenchSuite.Misc.Floating+import qualified BenchSuite.Misc.ModelExtract+import qualified BenchSuite.Misc.Newtypes+import qualified BenchSuite.Misc.NoDiv0+import qualified BenchSuite.Misc.Polynomials+import qualified BenchSuite.Misc.SetAlgebra+import qualified BenchSuite.Misc.SoftConstrain+import qualified BenchSuite.Misc.Tuple++-- | Lists+import qualified BenchSuite.Lists.BoundedMutex+import qualified BenchSuite.Lists.Fibonacci+import qualified BenchSuite.Lists.Nested++-- | Strings+import qualified BenchSuite.Strings.RegexCrossword+import qualified BenchSuite.Strings.SQLInjection++-- | Existentials+import qualified BenchSuite.Existentials.CRCPolynomial+import qualified BenchSuite.Existentials.Diophantine++-- | Transformers+import qualified BenchSuite.Transformers.SymbolicEval++ -- | Custom config to limit benchmarks to 5 minutes of runtime. This is required -- because we can easily generate benchmarks that take a lot of wall time to -- solve, especially with 'Data.SBV.allSatWith' calls benchConfig :: Config-benchConfig = defaultConfig {timeLimit = 300.00}+benchConfig = defaultConfig {timeLimit = Just 300.00}  -- The bench harness main :: IO () main = defaultMainWith benchConfig $        [ puzzles+       , bitPrecise+       , queries+       , weakestPreconditions+       , optimizations+       , uninterpreted+       , proofTools+       , codeGeneration+       , crypto+       , misc+       , lists+       , strings+       , transformers        ]  -- | Benchmarks for 'Documentation.SBV.Examples.Puzzles'. Each benchmark file -- defines a 'benchmarks' function which returns a--- 'BenchSuite.Overhead.SBVOverhead.Runner'. We want to allow benchmarks to be--- defined as closely as possible to the problems being solver. But for--- practical reasons we may desire to prevent benchmarking 'Data.SBV.allSat'--- calls because they could timeout. Thus by using--- 'BenchSuite.Overhead.SBVOverhead.Runner' we can define the benchmark--- mirroring the logic of the symbolic program. But that might be expensive to--- benchmark, so using this method we can change solver details _without_--- redefining the benchmark, as I have done below by converting all examples to--- use 'Data.SBV.satWith'.+-- 'BenchSuite.Bench.Bench.Runner'. We want to allow benchmarks to be defined as+-- closely as possible to the problems being solved. But for practical reasons+-- we may desire to prevent benchmarking 'Data.SBV.allSat' calls because they+-- could timeout. Thus by using 'BenchSuite.Bench.Bench.Runner' we can define+-- the benchmark mirroring the logic of the symbolic program and change solver+-- details _without_ redefining the benchmark, as I have done below by+-- converting all examples to use 'Data.SBV.satWith'. For benchmarks which do+-- not need to run with different solver configurations, such as queries we run+-- with `BenchSuite.Bench.Bench.Runner.runIO` puzzles :: Benchmark-puzzles = bgroup "Puzzles" $ (mkOverheadBenchMark . setRunner satWith) <$>+puzzles = bgroup "Puzzles" $ runBenchMark <$>           [ BenchSuite.Puzzles.Coins.benchmarks           , BenchSuite.Puzzles.Counts.benchmarks           , BenchSuite.Puzzles.Birthday.benchmarks@@ -69,3 +175,133 @@           , BenchSuite.Puzzles.Sudoku.benchmarks           , BenchSuite.Puzzles.U2Bridge.benchmarks           ]+++bitPrecise :: Benchmark+bitPrecise = bgroup "BitPrecise" $ runBenchMark <$>+             [ BenchSuite.BitPrecise.BitTricks.benchmarks+             , BenchSuite.BitPrecise.BrokenSearch.benchmarks+             , BenchSuite.BitPrecise.Legato.benchmarks+             , BenchSuite.BitPrecise.MergeSort.benchmarks+             , BenchSuite.BitPrecise.MultMask.benchmarks+             , BenchSuite.BitPrecise.PrefixSum.benchmarks+             ]+++queries :: Benchmark+queries = bgroup "Queries" $ runBenchMark <$>+          [ BenchSuite.Queries.AllSat.benchmarks+          , BenchSuite.Queries.CaseSplit.benchmarks+          , BenchSuite.Queries.Concurrency.benchmarks+          , BenchSuite.Queries.Enums.benchmarks+          , BenchSuite.Queries.FourFours.benchmarks+          , BenchSuite.Queries.GuessNumber.benchmarks+          , BenchSuite.Queries.Interpolants.benchmarks+          , BenchSuite.Queries.UnsatCore.benchmarks+          ]+++weakestPreconditions :: Benchmark+weakestPreconditions = bgroup "WeakestPreconditions" $ runBenchMark <$>+                       [ BenchSuite.WeakestPreconditions.Append.benchmarks+                       , BenchSuite.WeakestPreconditions.Basics.benchmarks+                       , BenchSuite.WeakestPreconditions.Fib.benchmarks+                       , BenchSuite.WeakestPreconditions.GCD.benchmarks+                       , BenchSuite.WeakestPreconditions.IntDiv.benchmarks+                       , BenchSuite.WeakestPreconditions.IntSqrt.benchmarks+                       , BenchSuite.WeakestPreconditions.Length.benchmarks+                       , BenchSuite.WeakestPreconditions.Sum.benchmarks+                       ]+++optimizations :: Benchmark+optimizations = bgroup "Optimizations" $ runBenchMark <$>+                [ BenchSuite.Optimization.Enumerate.benchmarks+                , BenchSuite.Optimization.ExtField.benchmarks+                , BenchSuite.Optimization.LinearOpt.benchmarks+                , BenchSuite.Optimization.Production.benchmarks+                , BenchSuite.Optimization.VM.benchmarks+                ]+++uninterpreted :: Benchmark+uninterpreted = bgroup "Uninterpreted" $ runBenchMark <$>+                [ BenchSuite.Uninterpreted.AUF.benchmarks+                , BenchSuite.Uninterpreted.Deduce.benchmarks+                , BenchSuite.Uninterpreted.Function.benchmarks+                , BenchSuite.Uninterpreted.Multiply.benchmarks+                , BenchSuite.Uninterpreted.Shannon.benchmarks+                , BenchSuite.Uninterpreted.Sort.benchmarks+                , BenchSuite.Uninterpreted.UISortAllSat.benchmarks+                ]+++proofTools :: Benchmark+proofTools = bgroup "ProofTools" $ runBenchMark <$>+             [ BenchSuite.ProofTools.BMC.benchmarks+             , BenchSuite.ProofTools.Fibonacci.benchmarks+             , BenchSuite.ProofTools.Strengthen.benchmarks+             , BenchSuite.ProofTools.Sum.benchmarks+             ]+++codeGeneration :: Benchmark+codeGeneration = bgroup "CodeGeneration" $ runBenchMark <$>+                 [ BenchSuite.CodeGeneration.AddSub.benchmarks+                 , BenchSuite.CodeGeneration.CRC_USB5.benchmarks+                 , BenchSuite.CodeGeneration.Fibonacci.benchmarks+                 , BenchSuite.CodeGeneration.GCD.benchmarks+                 , BenchSuite.CodeGeneration.PopulationCount.benchmarks+                 , BenchSuite.CodeGeneration.Uninterpreted.benchmarks+                 ]+++crypto :: Benchmark+crypto = bgroup "Crypto" $ runBenchMark <$>+         [ BenchSuite.Crypto.AES.benchmarks+         , BenchSuite.Crypto.RC4.benchmarks+         , BenchSuite.Crypto.SHA.benchmarks+         ]+++misc :: Benchmark+misc = bgroup "Miscellaneous" $ runBenchMark <$>+       [ BenchSuite.Misc.Auxiliary.benchmarks+       , BenchSuite.Misc.Enumerate.benchmarks+       , BenchSuite.Misc.Floating.benchmarks+       , BenchSuite.Misc.ModelExtract.benchmarks+       , BenchSuite.Misc.Newtypes.benchmarks+       , BenchSuite.Misc.NoDiv0.benchmarks+       , BenchSuite.Misc.Polynomials.benchmarks+       , BenchSuite.Misc.SetAlgebra.benchmarks+       , BenchSuite.Misc.SoftConstrain.benchmarks+       , BenchSuite.Misc.Tuple.benchmarks+       ]+++lists :: Benchmark+lists = bgroup "Lists" $ runBenchMark <$>+        [ BenchSuite.Lists.BoundedMutex.benchmarks+        , BenchSuite.Lists.Fibonacci.benchmarks+        , BenchSuite.Lists.Nested.benchmarks+        ]+++strings :: Benchmark+strings = bgroup "Strings" $ runBenchMark <$>+          [ BenchSuite.Strings.RegexCrossword.benchmarks+          , BenchSuite.Strings.SQLInjection.benchmarks+          ]+++existentials :: Benchmark+existentials = bgroup "Existentials" $ runBenchMark <$>+               [ BenchSuite.Existentials.CRCPolynomial.benchmarks+               , BenchSuite.Existentials.Diophantine.benchmarks+               ]+++transformers :: Benchmark+transformers = bgroup "Transformers" $ runBenchMark <$>+               [ BenchSuite.Transformers.SymbolicEval.benchmarks+               ]
SBVBenchSuite/Utils/SBVBenchFramework.hs view
@@ -13,7 +13,7 @@ module Utils.SBVBenchFramework   ( mkExecString   , mkFileName-  , module Criterion.Main+  , module Gauge.Main   , module Data.SBV   ) where @@ -21,7 +21,7 @@ import           System.Process (showCommandForUser) import           System.Random -import           Criterion.Main (Benchmark, bgroup)+import           Gauge.Main (Benchmark, bgroup)  import           Data.SBV
SBVTestSuite/GoldFiles/allSat6.gold view
@@ -2,9 +2,9 @@   x = 0 :: Word8   y = 1 :: Word8 Solution #2:-  x = 0 :: Word8+  x = 1 :: Word8   y = 2 :: Word8 Solution #3:-  x = 1 :: Word8+  x = 0 :: Word8   y = 2 :: Word8 Found 3 different solutions. (Unique up to prefix existentials.)
SBVTestSuite/GoldFiles/barrelRotate_Left_Int16_Word16.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Left_Int16_Word32.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Left_Int16_Word64.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Left_Int16_Word8.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Left_Int32_Word16.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Left_Int32_Word32.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Left_Int32_Word64.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Left_Int32_Word8.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Left_Int64_Word16.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Left_Int64_Word32.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Left_Int64_Word64.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Left_Int64_Word8.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Left_Int8_Word16.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Left_Int8_Word32.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Left_Int8_Word64.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Left_Int8_Word8.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Left_Word16_Word16.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Left_Word16_Word32.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Left_Word16_Word64.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Left_Word16_Word8.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Left_Word32_Word16.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Left_Word32_Word32.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Left_Word32_Word64.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Left_Word32_Word8.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Left_Word64_Word16.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Left_Word64_Word32.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Left_Word64_Word64.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Left_Word64_Word8.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Left_Word8_Word16.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Left_Word8_Word32.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Left_Word8_Word64.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Left_Word8_Word8.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Right_Int16_Word16.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Right_Int16_Word32.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Right_Int16_Word64.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Right_Int16_Word8.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Right_Int32_Word16.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Right_Int32_Word32.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Right_Int32_Word64.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Right_Int32_Word8.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Right_Int64_Word16.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Right_Int64_Word32.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Right_Int64_Word64.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Right_Int64_Word8.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Right_Int8_Word16.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Right_Int8_Word32.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Right_Int8_Word64.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Right_Int8_Word8.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Right_Word16_Word16.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Right_Word16_Word32.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Right_Word16_Word64.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Right_Word16_Word8.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Right_Word32_Word16.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Right_Word32_Word32.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Right_Word32_Word64.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Right_Word32_Word8.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Right_Word64_Word16.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Right_Word64_Word32.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Right_Word64_Word64.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Right_Word64_Word8.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Right_Word8_Word16.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Right_Word8_Word32.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Right_Word8_Word64.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/barrelRotate_Right_Word8_Word8.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/boxed1.gold view
@@ -1,20 +1,20 @@ Objective "min_x": Optimal in an extension field:-  min_x        =     0.0 :: Real-  max_x_plus_y =    13.0 :: Real-  min_y        = epsilon :: Real-  max_y        =     4.0 :: Real+  min_x        =           0.0 :: Real+  max_x_plus_y =          13.0 :: Real+  min_y        = 2.0 * epsilon :: Real+  max_y        =           4.0 :: Real Objective "max_x_plus_y": Optimal in an extension field:-  min_x        =     0.0 :: Real-  max_x_plus_y =    13.0 :: Real-  min_y        = epsilon :: Real-  max_y        =     4.0 :: Real+  min_x        =           0.0 :: Real+  max_x_plus_y =          13.0 :: Real+  min_y        = 2.0 * epsilon :: Real+  max_y        =           4.0 :: Real Objective "min_y": Optimal in an extension field:-  min_x        =     0.0 :: Real-  max_x_plus_y =    13.0 :: Real-  min_y        = epsilon :: Real-  max_y        =     4.0 :: Real+  min_x        =           0.0 :: Real+  max_x_plus_y =          13.0 :: Real+  min_y        = 2.0 * epsilon :: Real+  max_y        =           4.0 :: Real Objective "max_y": Optimal in an extension field:-  min_x        =     0.0 :: Real-  max_x_plus_y =    13.0 :: Real-  min_y        = epsilon :: Real-  max_y        =     4.0 :: Real+  min_x        =           0.0 :: Real+  max_x_plus_y =          13.0 :: Real+  min_y        = 2.0 * epsilon :: Real+  max_y        =           4.0 :: Real
SBVTestSuite/GoldFiles/freshVars.gold view
@@ -82,6 +82,7 @@ [GOOD] (define-fun s42 () Bool (= s16 s41)) [GOOD] (assert s42) [GOOD] (declare-fun array_0 () (Array Int Int))+[GOOD] (define-fun array_0_initializer () Bool true) ; no initializiation needed [GOOD] (declare-fun s43 () Int) [GOOD] (declare-fun s44 () Bool) [GOOD] (define-fun s46 () Int 2)@@ -95,6 +96,7 @@ [GOOD] (assert s50) [GOOD] (define-fun s51 () Int 42) [GOOD] (define-fun array_1 () (Array Int Int) ((as const (Array Int Int)) 42))+[GOOD] (define-fun array_1_initializer () Bool true) ; no initializiation needed [GOOD] (declare-fun s52 () Int) [GOOD] (declare-fun s53 () (_ BitVec 8)) [GOOD] (define-fun s54 () Int 96)@@ -167,6 +169,11 @@ [RECV] ((s12 (fp #b0 #x82 #b00100000000000000000000))) [SEND] (get-value (s13)) [RECV] ((s13 (fp #b0 #b10000000010 #x4000000000000)))+[GOOD] (set-option :pp.decimal false)+[SEND] (get-value (s14))+[RECV] ((s14 11.0))+[GOOD] (set-option :pp.decimal true)+[GOOD] (set-option :pp.decimal_precision 16) [SEND] (get-value (s14)) [RECV] ((s14 11.0)) [SEND] (get-value (s15))
SBVTestSuite/GoldFiles/optExtField3.gold view
@@ -1,2 +1,2 @@ Optimal in an extension field:-  x_plus_y = 9.0 + (-2.0 * epsilon) :: Real+  x_plus_y = 9.0 + (-3.0 * epsilon) :: Real
SBVTestSuite/GoldFiles/pareto1.gold view
@@ -1,180 +1,180 @@ Pareto front #1: Optimal model:-  x            = 0 :: Integer-  y            = 0 :: Integer-  min_x        = 0 :: Integer-  max_x_plus_y = 0 :: Integer-  min_y        = 0 :: Integer-Pareto front #2: Optimal model:-  x            = 0 :: Integer-  y            = 1 :: Integer-  min_x        = 0 :: Integer-  max_x_plus_y = 1 :: Integer-  min_y        = 1 :: Integer-Pareto front #3: Optimal model:   x            = 1 :: Integer   y            = 1 :: Integer   min_x        = 1 :: Integer   max_x_plus_y = 2 :: Integer   min_y        = 1 :: Integer-Pareto front #4: Optimal model:-  x            = 1 :: Integer-  y            = 0 :: Integer-  min_x        = 1 :: Integer-  max_x_plus_y = 1 :: Integer-  min_y        = 0 :: Integer-Pareto front #5: Optimal model:+Pareto front #2: Optimal model:   x            = 0 :: Integer-  y            = 2 :: Integer+  y            = 3 :: Integer   min_x        = 0 :: Integer-  max_x_plus_y = 2 :: Integer-  min_y        = 2 :: Integer-Pareto front #6: Optimal model:-  x            = 1 :: Integer-  y            = 2 :: Integer-  min_x        = 1 :: Integer   max_x_plus_y = 3 :: Integer-  min_y        = 2 :: Integer-Pareto front #7: Optimal model:+  min_y        = 3 :: Integer+Pareto front #3: Optimal model:+  x            = 0 :: Integer+  y            = 4 :: Integer+  min_x        = 0 :: Integer+  max_x_plus_y = 4 :: Integer+  min_y        = 4 :: Integer+Pareto front #4: Optimal model:   x            = 2 :: Integer-  y            = 0 :: Integer+  y            = 4 :: Integer   min_x        = 2 :: Integer-  max_x_plus_y = 2 :: Integer-  min_y        = 0 :: Integer+  max_x_plus_y = 6 :: Integer+  min_y        = 4 :: Integer+Pareto front #5: Optimal model:+  x            = 3 :: Integer+  y            = 4 :: Integer+  min_x        = 3 :: Integer+  max_x_plus_y = 7 :: Integer+  min_y        = 4 :: Integer+Pareto front #6: Optimal model:+  x            = 4 :: Integer+  y            = 4 :: Integer+  min_x        = 4 :: Integer+  max_x_plus_y = 8 :: Integer+  min_y        = 4 :: Integer+Pareto front #7: Optimal model:+  x            = 5 :: Integer+  y            = 4 :: Integer+  min_x        = 5 :: Integer+  max_x_plus_y = 9 :: Integer+  min_y        = 4 :: Integer Pareto front #8: Optimal model:-  x            = 2 :: Integer-  y            = 1 :: Integer-  min_x        = 2 :: Integer-  max_x_plus_y = 3 :: Integer-  min_y        = 1 :: Integer+  x            = 1 :: Integer+  y            = 4 :: Integer+  min_x        = 1 :: Integer+  max_x_plus_y = 5 :: Integer+  min_y        = 4 :: Integer Pareto front #9: Optimal model:   x            = 3 :: Integer-  y            = 0 :: Integer+  y            = 2 :: Integer   min_x        = 3 :: Integer-  max_x_plus_y = 3 :: Integer-  min_y        = 0 :: Integer+  max_x_plus_y = 5 :: Integer+  min_y        = 2 :: Integer Pareto front #10: Optimal model:-  x            = 3 :: Integer+  x            = 4 :: Integer   y            = 1 :: Integer-  min_x        = 3 :: Integer-  max_x_plus_y = 4 :: Integer+  min_x        = 4 :: Integer+  max_x_plus_y = 5 :: Integer   min_y        = 1 :: Integer Pareto front #11: Optimal model:-  x            = 4 :: Integer-  y            = 0 :: Integer-  min_x        = 4 :: Integer-  max_x_plus_y = 4 :: Integer-  min_y        = 0 :: Integer-Pareto front #12: Optimal model:   x            = 5 :: Integer   y            = 0 :: Integer   min_x        = 5 :: Integer   max_x_plus_y = 5 :: Integer   min_y        = 0 :: Integer-Pareto front #13: Optimal model:-  x            = 4 :: Integer-  y            = 1 :: Integer-  min_x        = 4 :: Integer+Pareto front #12: Optimal model:+  x            = 2 :: Integer+  y            = 3 :: Integer+  min_x        = 2 :: Integer   max_x_plus_y = 5 :: Integer-  min_y        = 1 :: Integer-Pareto front #14: Optimal model:+  min_y        = 3 :: Integer+Pareto front #13: Optimal model:   x            = 5 :: Integer   y            = 1 :: Integer   min_x        = 5 :: Integer   max_x_plus_y = 6 :: Integer   min_y        = 1 :: Integer-Pareto front #15: Optimal model:-  x            = 2 :: Integer+Pareto front #14: Optimal model:+  x            = 4 :: Integer   y            = 2 :: Integer-  min_x        = 2 :: Integer-  max_x_plus_y = 4 :: Integer+  min_x        = 4 :: Integer+  max_x_plus_y = 6 :: Integer   min_y        = 2 :: Integer-Pareto front #16: Optimal model:-  x            = 0 :: Integer+Pareto front #15: Optimal model:+  x            = 4 :: Integer   y            = 3 :: Integer-  min_x        = 0 :: Integer-  max_x_plus_y = 3 :: Integer+  min_x        = 4 :: Integer+  max_x_plus_y = 7 :: Integer   min_y        = 3 :: Integer+Pareto front #16: Optimal model:+  x            = 5 :: Integer+  y            = 2 :: Integer+  min_x        = 5 :: Integer+  max_x_plus_y = 7 :: Integer+  min_y        = 2 :: Integer Pareto front #17: Optimal model:-  x            = 1 :: Integer+  x            = 3 :: Integer   y            = 3 :: Integer-  min_x        = 1 :: Integer-  max_x_plus_y = 4 :: Integer+  min_x        = 3 :: Integer+  max_x_plus_y = 6 :: Integer   min_y        = 3 :: Integer Pareto front #18: Optimal model:+  x            = 5 :: Integer+  y            = 3 :: Integer+  min_x        = 5 :: Integer+  max_x_plus_y = 8 :: Integer+  min_y        = 3 :: Integer+Pareto front #19: Optimal model:   x            = 0 :: Integer-  y            = 4 :: Integer+  y            = 0 :: Integer   min_x        = 0 :: Integer-  max_x_plus_y = 4 :: Integer-  min_y        = 4 :: Integer-Pareto front #19: Optimal model:+  max_x_plus_y = 0 :: Integer+  min_y        = 0 :: Integer+Pareto front #20: Optimal model:   x            = 1 :: Integer-  y            = 4 :: Integer+  y            = 0 :: Integer   min_x        = 1 :: Integer-  max_x_plus_y = 5 :: Integer-  min_y        = 4 :: Integer-Pareto front #20: Optimal model:-  x            = 2 :: Integer-  y            = 3 :: Integer-  min_x        = 2 :: Integer-  max_x_plus_y = 5 :: Integer-  min_y        = 3 :: Integer+  max_x_plus_y = 1 :: Integer+  min_y        = 0 :: Integer Pareto front #21: Optimal model:+  x            = 0 :: Integer+  y            = 1 :: Integer+  min_x        = 0 :: Integer+  max_x_plus_y = 1 :: Integer+  min_y        = 1 :: Integer+Pareto front #22: Optimal model:   x            = 2 :: Integer-  y            = 4 :: Integer+  y            = 0 :: Integer   min_x        = 2 :: Integer-  max_x_plus_y = 6 :: Integer-  min_y        = 4 :: Integer-Pareto front #22: Optimal model:-  x            = 3 :: Integer-  y            = 2 :: Integer-  min_x        = 3 :: Integer-  max_x_plus_y = 5 :: Integer-  min_y        = 2 :: Integer+  max_x_plus_y = 2 :: Integer+  min_y        = 0 :: Integer Pareto front #23: Optimal model:   x            = 3 :: Integer-  y            = 3 :: Integer+  y            = 0 :: Integer   min_x        = 3 :: Integer-  max_x_plus_y = 6 :: Integer-  min_y        = 3 :: Integer+  max_x_plus_y = 3 :: Integer+  min_y        = 0 :: Integer Pareto front #24: Optimal model:+  x            = 2 :: Integer+  y            = 1 :: Integer+  min_x        = 2 :: Integer+  max_x_plus_y = 3 :: Integer+  min_y        = 1 :: Integer+Pareto front #25: Optimal model:   x            = 3 :: Integer-  y            = 4 :: Integer+  y            = 1 :: Integer   min_x        = 3 :: Integer-  max_x_plus_y = 7 :: Integer-  min_y        = 4 :: Integer-Pareto front #25: Optimal model:-  x            = 4 :: Integer-  y            = 2 :: Integer-  min_x        = 4 :: Integer-  max_x_plus_y = 6 :: Integer-  min_y        = 2 :: Integer+  max_x_plus_y = 4 :: Integer+  min_y        = 1 :: Integer Pareto front #26: Optimal model:-  x            = 5 :: Integer+  x            = 1 :: Integer   y            = 2 :: Integer-  min_x        = 5 :: Integer-  max_x_plus_y = 7 :: Integer+  min_x        = 1 :: Integer+  max_x_plus_y = 3 :: Integer   min_y        = 2 :: Integer Pareto front #27: Optimal model:-  x            = 4 :: Integer+  x            = 1 :: Integer   y            = 3 :: Integer-  min_x        = 4 :: Integer-  max_x_plus_y = 7 :: Integer+  min_x        = 1 :: Integer+  max_x_plus_y = 4 :: Integer   min_y        = 3 :: Integer Pareto front #28: Optimal model:-  x            = 5 :: Integer-  y            = 3 :: Integer-  min_x        = 5 :: Integer-  max_x_plus_y = 8 :: Integer-  min_y        = 3 :: Integer-Pareto front #29: Optimal model:   x            = 4 :: Integer-  y            = 4 :: Integer+  y            = 0 :: Integer   min_x        = 4 :: Integer-  max_x_plus_y = 8 :: Integer-  min_y        = 4 :: Integer+  max_x_plus_y = 4 :: Integer+  min_y        = 0 :: Integer+Pareto front #29: Optimal model:+  x            = 2 :: Integer+  y            = 2 :: Integer+  min_x        = 2 :: Integer+  max_x_plus_y = 4 :: Integer+  min_y        = 2 :: Integer Pareto front #30: Optimal model:-  x            = 5 :: Integer-  y            = 4 :: Integer-  min_x        = 5 :: Integer-  max_x_plus_y = 9 :: Integer-  min_y        = 4 :: Integer+  x            = 0 :: Integer+  y            = 2 :: Integer+  min_x        = 0 :: Integer+  max_x_plus_y = 2 :: Integer+  min_y        = 2 :: Integer
SBVTestSuite/GoldFiles/pareto2.gold view
@@ -1,182 +1,182 @@ Pareto front #1: Optimal model:   x            = 0 :: Integer-  y            = 0 :: Integer-  min_x        = 0 :: Integer-  max_y        = 0 :: Integer-  max_x_plus_y = 0 :: Integer-Pareto front #2: Optimal model:-  x            = 0 :: Integer   y            = 1 :: Integer   min_x        = 0 :: Integer   max_y        = 1 :: Integer   max_x_plus_y = 1 :: Integer-Pareto front #3: Optimal model:+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            = -1 :: Integer-  min_x        =  0 :: Integer-  max_y        = -1 :: Integer-  max_x_plus_y = -1 :: Integer+  x            = 0 :: Integer+  y            = 4 :: Integer+  min_x        = 0 :: Integer+  max_y        = 4 :: Integer+  max_x_plus_y = 4 :: Integer Pareto front #5: Optimal model:-  x            =  0 :: Integer-  y            = -2 :: Integer-  min_x        =  0 :: Integer-  max_y        = -2 :: Integer-  max_x_plus_y = -2 :: Integer+  x            = 0 :: Integer+  y            = 6 :: Integer+  min_x        = 0 :: Integer+  max_y        = 6 :: Integer+  max_x_plus_y = 6 :: Integer Pareto front #6: Optimal model:-  x            =  0 :: Integer-  y            = -3 :: Integer-  min_x        =  0 :: Integer-  max_y        = -3 :: Integer-  max_x_plus_y = -3 :: Integer+  x            = 0 :: Integer+  y            = 7 :: Integer+  min_x        = 0 :: Integer+  max_y        = 7 :: Integer+  max_x_plus_y = 7 :: Integer Pareto front #7: Optimal model:   x            = 0 :: Integer-  y            = 3 :: Integer+  y            = 9 :: Integer   min_x        = 0 :: Integer-  max_y        = 3 :: Integer-  max_x_plus_y = 3 :: Integer+  max_y        = 9 :: Integer+  max_x_plus_y = 9 :: Integer Pareto front #8: Optimal model:   x            =  0 :: Integer-  y            = -4 :: Integer+  y            = 10 :: Integer   min_x        =  0 :: Integer-  max_y        = -4 :: Integer-  max_x_plus_y = -4 :: Integer+  max_y        = 10 :: Integer+  max_x_plus_y = 10 :: Integer Pareto front #9: Optimal model:   x            =  0 :: Integer-  y            = -5 :: Integer+  y            = 12 :: Integer   min_x        =  0 :: Integer-  max_y        = -5 :: Integer-  max_x_plus_y = -5 :: Integer+  max_y        = 12 :: Integer+  max_x_plus_y = 12 :: Integer Pareto front #10: Optimal model:   x            =  0 :: Integer-  y            = -6 :: Integer+  y            = 14 :: Integer   min_x        =  0 :: Integer-  max_y        = -6 :: Integer-  max_x_plus_y = -6 :: Integer+  max_y        = 14 :: Integer+  max_x_plus_y = 14 :: Integer Pareto front #11: Optimal model:   x            =  0 :: Integer-  y            = -7 :: Integer+  y            = 16 :: Integer   min_x        =  0 :: Integer-  max_y        = -7 :: Integer-  max_x_plus_y = -7 :: Integer+  max_y        = 16 :: Integer+  max_x_plus_y = 16 :: Integer Pareto front #12: Optimal model:   x            =  0 :: Integer-  y            = -8 :: Integer+  y            = 17 :: Integer   min_x        =  0 :: Integer-  max_y        = -8 :: Integer-  max_x_plus_y = -8 :: Integer+  max_y        = 17 :: Integer+  max_x_plus_y = 17 :: Integer Pareto front #13: Optimal model:   x            =  0 :: Integer-  y            = -9 :: Integer+  y            = 19 :: Integer   min_x        =  0 :: Integer-  max_y        = -9 :: Integer-  max_x_plus_y = -9 :: Integer+  max_y        = 19 :: Integer+  max_x_plus_y = 19 :: Integer Pareto front #14: Optimal model:-  x            =   0 :: Integer-  y            = -10 :: Integer-  min_x        =   0 :: Integer-  max_y        = -10 :: Integer-  max_x_plus_y = -10 :: Integer+  x            =  0 :: Integer+  y            = 21 :: Integer+  min_x        =  0 :: Integer+  max_y        = 21 :: Integer+  max_x_plus_y = 21 :: Integer Pareto front #15: Optimal model:-  x            =   0 :: Integer-  y            = -11 :: Integer-  min_x        =   0 :: Integer-  max_y        = -11 :: Integer-  max_x_plus_y = -11 :: Integer+  x            =  0 :: Integer+  y            = 23 :: Integer+  min_x        =  0 :: Integer+  max_y        = 23 :: Integer+  max_x_plus_y = 23 :: Integer Pareto front #16: Optimal model:-  x            =   0 :: Integer-  y            = -12 :: Integer-  min_x        =   0 :: Integer-  max_y        = -12 :: Integer-  max_x_plus_y = -12 :: Integer+  x            =  0 :: Integer+  y            = 25 :: Integer+  min_x        =  0 :: Integer+  max_y        = 25 :: Integer+  max_x_plus_y = 25 :: Integer Pareto front #17: Optimal model:-  x            =   0 :: Integer-  y            = -13 :: Integer-  min_x        =   0 :: Integer-  max_y        = -13 :: Integer-  max_x_plus_y = -13 :: Integer+  x            =  0 :: Integer+  y            = 26 :: Integer+  min_x        =  0 :: Integer+  max_y        = 26 :: Integer+  max_x_plus_y = 26 :: Integer Pareto front #18: Optimal model:-  x            =   0 :: Integer-  y            = -14 :: Integer-  min_x        =   0 :: Integer-  max_y        = -14 :: Integer-  max_x_plus_y = -14 :: Integer+  x            =  0 :: Integer+  y            = 27 :: Integer+  min_x        =  0 :: Integer+  max_y        = 27 :: Integer+  max_x_plus_y = 27 :: Integer Pareto front #19: Optimal model:-  x            = 0 :: Integer-  y            = 4 :: Integer-  min_x        = 0 :: Integer-  max_y        = 4 :: Integer-  max_x_plus_y = 4 :: Integer+  x            =  0 :: Integer+  y            = 28 :: Integer+  min_x        =  0 :: Integer+  max_y        = 28 :: Integer+  max_x_plus_y = 28 :: Integer Pareto front #20: Optimal model:-  x            = 0 :: Integer-  y            = 5 :: Integer-  min_x        = 0 :: Integer-  max_y        = 5 :: Integer-  max_x_plus_y = 5 :: Integer+  x            =  0 :: Integer+  y            = 30 :: Integer+  min_x        =  0 :: Integer+  max_y        = 30 :: Integer+  max_x_plus_y = 30 :: Integer Pareto front #21: Optimal model:-  x            = 0 :: Integer-  y            = 6 :: Integer-  min_x        = 0 :: Integer-  max_y        = 6 :: Integer-  max_x_plus_y = 6 :: Integer+  x            =  0 :: Integer+  y            = 32 :: Integer+  min_x        =  0 :: Integer+  max_y        = 32 :: Integer+  max_x_plus_y = 32 :: Integer Pareto front #22: Optimal model:-  x            =   0 :: Integer-  y            = -15 :: Integer-  min_x        =   0 :: Integer-  max_y        = -15 :: Integer-  max_x_plus_y = -15 :: Integer+  x            =  0 :: Integer+  y            = 33 :: Integer+  min_x        =  0 :: Integer+  max_y        = 33 :: Integer+  max_x_plus_y = 33 :: Integer Pareto front #23: Optimal model:-  x            =   0 :: Integer-  y            = -16 :: Integer-  min_x        =   0 :: Integer-  max_y        = -16 :: Integer-  max_x_plus_y = -16 :: Integer+  x            =  0 :: Integer+  y            = 34 :: Integer+  min_x        =  0 :: Integer+  max_y        = 34 :: Integer+  max_x_plus_y = 34 :: Integer Pareto front #24: Optimal model:-  x            =   0 :: Integer-  y            = -17 :: Integer-  min_x        =   0 :: Integer-  max_y        = -17 :: Integer-  max_x_plus_y = -17 :: Integer+  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            = -18 :: Integer-  min_x        =   0 :: Integer-  max_y        = -18 :: Integer-  max_x_plus_y = -18 :: Integer+  x            =  0 :: Integer+  y            = 37 :: Integer+  min_x        =  0 :: Integer+  max_y        = 37 :: Integer+  max_x_plus_y = 37 :: Integer Pareto front #26: Optimal model:-  x            =   0 :: Integer-  y            = -19 :: Integer-  min_x        =   0 :: Integer-  max_y        = -19 :: Integer-  max_x_plus_y = -19 :: Integer+  x            =  0 :: Integer+  y            = 38 :: Integer+  min_x        =  0 :: Integer+  max_y        = 38 :: Integer+  max_x_plus_y = 38 :: Integer Pareto front #27: Optimal model:-  x            =   0 :: Integer-  y            = -20 :: Integer-  min_x        =   0 :: Integer-  max_y        = -20 :: Integer-  max_x_plus_y = -20 :: Integer+  x            =  0 :: Integer+  y            = 40 :: Integer+  min_x        =  0 :: Integer+  max_y        = 40 :: Integer+  max_x_plus_y = 40 :: Integer Pareto front #28: Optimal model:-  x            =   0 :: Integer-  y            = -21 :: Integer-  min_x        =   0 :: Integer-  max_y        = -21 :: Integer-  max_x_plus_y = -21 :: Integer+  x            =  0 :: Integer+  y            = 42 :: Integer+  min_x        =  0 :: Integer+  max_y        = 42 :: Integer+  max_x_plus_y = 42 :: Integer Pareto front #29: Optimal model:-  x            =   0 :: Integer-  y            = -22 :: Integer-  min_x        =   0 :: Integer-  max_y        = -22 :: Integer-  max_x_plus_y = -22 :: Integer+  x            =  0 :: Integer+  y            = 43 :: Integer+  min_x        =  0 :: Integer+  max_y        = 43 :: Integer+  max_x_plus_y = 43 :: Integer Pareto front #30: Optimal model:-  x            =   0 :: Integer-  y            = -23 :: Integer-  min_x        =   0 :: Integer-  max_y        = -23 :: Integer-  max_x_plus_y = -23 :: Integer+  x            =  0 :: Integer+  y            = 44 :: Integer+  min_x        =  0 :: Integer+  max_y        = 44 :: Integer+  max_x_plus_y = 44 :: Integer *** Note: Pareto-front extraction was terminated as requested by the user. ***       There might be many other results!
SBVTestSuite/GoldFiles/pareto3.gold view
@@ -1,8 +1,8 @@ Pareto front #1: Optimal model:-  x            = 0 :: Integer-  min_x        = 0 :: Integer-  max_x_plus_x = 0 :: Integer-Pareto front #2: Optimal model:   x            = 1 :: Integer   min_x        = 1 :: Integer   max_x_plus_x = 2 :: Integer+Pareto front #2: Optimal model:+  x            = 0 :: Integer+  min_x        = 0 :: Integer+  max_x_plus_x = 0 :: Integer
SBVTestSuite/GoldFiles/query1.gold view
@@ -73,7 +73,7 @@ [SEND] (get-info :reason-unknown) [RECV] (:reason-unknown "state of the most recent check-sat command is not known") [SEND] (get-info :version)-[RECV] (:version "4.8.8")+[RECV] (:version "4.8.9") [SEND] (get-info :status) [RECV] (:status sat) [GOOD] (define-fun s16 () Int 4)@@ -104,7 +104,7 @@ [SEND] (get-info :reason-unknown) [RECV] (:reason-unknown "unknown") [SEND] (get-info :version)-[RECV] (:version "4.8.8")+[RECV] (:version "4.8.9") [SEND] (get-info :memory) [RECV] unsupported [SEND] (get-info :time)@@ -149,20 +149,19 @@        (declare-fun bey () Bool)        (declare-fun hey () Bool)        (proof-       (let (($x232 (<= s0 6)))-        (let (($x233 (not $x232)))-        (let (($x240 (or (not bey) $x233)))-        (let ((@x238 (monotonicity (rewrite (= (> s0 6) $x233)) (= (=> bey (> s0 6)) (=> bey $x233)))))-        (let ((@x244 (trans @x238 (rewrite (= (=> bey $x233) $x240)) (= (=> bey (> s0 6)) $x240))))-        (let ((@x245 (mp (asserted (=> bey (> s0 6))) @x244 $x240)))-        (let (($x257 (>= s0 6)))-        (let (($x256 (not $x257)))-        (let (($x266 (or (not hey) $x256)))-        (let ((@x259 (monotonicity (rewrite (= (<= 6 s0) $x257)) (= (not (<= 6 s0)) $x256))))-        (let ((@x261 (trans (rewrite (= (< s0 6) (not (<= 6 s0)))) @x259 (= (< s0 6) $x256))))-        (let ((@x270 (trans (monotonicity @x261 (= (=> hey (< s0 6)) (=> hey $x256))) (rewrite (= (=> hey $x256) $x266)) (= (=> hey (< s0 6)) $x266))))-        (let ((@x271 (mp (asserted (=> hey (< s0 6))) @x270 $x266)))-        (unit-resolution ((_ th-lemma arith farkas 1 1) (or $x257 $x232)) (unit-resolution @x271 (asserted hey) $x256) (unit-resolution @x245 (asserted bey) $x233) false))))))))))))))))+       (let (($x224 (<= s0 6)))+        (let (($x225 (not $x224)))+        (let (($x232 (or (not bey) $x225)))+        (let ((@x230 (monotonicity (rewrite (= (> s0 6) $x225)) (= (=> bey (> s0 6)) (=> bey $x225)))))+        (let ((@x236 (trans @x230 (rewrite (= (=> bey $x225) $x232)) (= (=> bey (> s0 6)) $x232))))+        (let ((@x237 (mp (asserted (=> bey (> s0 6))) @x236 $x232)))+        (let (($x249 (>= s0 6)))+        (let (($x248 (not $x249)))+        (let (($x256 (or (not hey) $x248)))+        (let ((@x247 (trans (rewrite (= (< s0 6) (not (<= 6 s0)))) (rewrite (= (not (<= 6 s0)) $x248)) (= (< s0 6) $x248))))+        (let ((@x260 (trans (monotonicity @x247 (= (=> hey (< s0 6)) (=> hey $x248))) (rewrite (= (=> hey $x248) $x256)) (= (=> hey (< s0 6)) $x256))))+        (let ((@x261 (mp (asserted (=> hey (< s0 6))) @x260 $x256)))+        (unit-resolution ((_ th-lemma arith farkas 1 1) (or $x249 $x224)) (unit-resolution @x261 (asserted hey) $x248) (unit-resolution @x237 (asserted bey) $x225) false))))))))))))))) [SEND, TimeOut: 90000ms] (get-assertions)  [RECV] ((! s7 :named |a > 0|)
SBVTestSuite/GoldFiles/queryArrays1.gold view
@@ -22,11 +22,14 @@ [GOOD] ; --- user given axioms --- [GOOD] ; --- formula --- [GOOD] (define-fun s2 () Bool (distinct s0 s1))+[GOOD] (define-fun array_0_initializer () Bool true) ; no initializiation needed [GOOD] (assert s2) [GOOD] (declare-fun array_1 () (Array (_ BitVec 8) (_ BitVec 8))) [GOOD] (define-fun s4 () (_ BitVec 8) (select array_1 s0)) [GOOD] (define-fun s5 () Bool (= s3 s4))-[GOOD] (assert (= array_1 (store array_0 s0 s3)))+[GOOD] (define-fun array_1_initializer_0 () Bool (= array_1 (store array_0 s0 s3)))+[GOOD] (define-fun array_1_initializer () Bool array_1_initializer_0)+[GOOD] (assert array_1_initializer) [GOOD] (assert s5) [SEND] (check-sat) [RECV] sat
SBVTestSuite/GoldFiles/queryArrays2.gold view
@@ -275,262 +275,264 @@ [GOOD] (define-fun s255 () (_ BitVec 8) #xfe) [GOOD] (define-fun s256 () (_ BitVec 8) #xff) [GOOD] (declare-fun table0 ((_ BitVec 8)) (_ BitVec 8))-[GOOD] (assert (= (table0 #x00) s1))-[GOOD] (assert (= (table0 #x01) s2))-[GOOD] (assert (= (table0 #x02) s3))-[GOOD] (assert (= (table0 #x03) s4))-[GOOD] (assert (= (table0 #x04) s5))-[GOOD] (assert (= (table0 #x05) s6))-[GOOD] (assert (= (table0 #x06) s7))-[GOOD] (assert (= (table0 #x07) s8))-[GOOD] (assert (= (table0 #x08) s9))-[GOOD] (assert (= (table0 #x09) s10))-[GOOD] (assert (= (table0 #x0a) s11))-[GOOD] (assert (= (table0 #x0b) s12))-[GOOD] (assert (= (table0 #x0c) s13))-[GOOD] (assert (= (table0 #x0d) s14))-[GOOD] (assert (= (table0 #x0e) s15))-[GOOD] (assert (= (table0 #x0f) s16))-[GOOD] (assert (= (table0 #x10) s17))-[GOOD] (assert (= (table0 #x11) s18))-[GOOD] (assert (= (table0 #x12) s19))-[GOOD] (assert (= (table0 #x13) s20))-[GOOD] (assert (= (table0 #x14) s21))-[GOOD] (assert (= (table0 #x15) s22))-[GOOD] (assert (= (table0 #x16) s23))-[GOOD] (assert (= (table0 #x17) s24))-[GOOD] (assert (= (table0 #x18) s25))-[GOOD] (assert (= (table0 #x19) s26))-[GOOD] (assert (= (table0 #x1a) s27))-[GOOD] (assert (= (table0 #x1b) s28))-[GOOD] (assert (= (table0 #x1c) s29))-[GOOD] (assert (= (table0 #x1d) s30))-[GOOD] (assert (= (table0 #x1e) s31))-[GOOD] (assert (= (table0 #x1f) s32))-[GOOD] (assert (= (table0 #x20) s33))-[GOOD] (assert (= (table0 #x21) s34))-[GOOD] (assert (= (table0 #x22) s35))-[GOOD] (assert (= (table0 #x23) s36))-[GOOD] (assert (= (table0 #x24) s37))-[GOOD] (assert (= (table0 #x25) s38))-[GOOD] (assert (= (table0 #x26) s39))-[GOOD] (assert (= (table0 #x27) s40))-[GOOD] (assert (= (table0 #x28) s41))-[GOOD] (assert (= (table0 #x29) s42))-[GOOD] (assert (= (table0 #x2a) s43))-[GOOD] (assert (= (table0 #x2b) s44))-[GOOD] (assert (= (table0 #x2c) s45))-[GOOD] (assert (= (table0 #x2d) s46))-[GOOD] (assert (= (table0 #x2e) s47))-[GOOD] (assert (= (table0 #x2f) s48))-[GOOD] (assert (= (table0 #x30) s49))-[GOOD] (assert (= (table0 #x31) s50))-[GOOD] (assert (= (table0 #x32) s51))-[GOOD] (assert (= (table0 #x33) s52))-[GOOD] (assert (= (table0 #x34) s53))-[GOOD] (assert (= (table0 #x35) s54))-[GOOD] (assert (= (table0 #x36) s55))-[GOOD] (assert (= (table0 #x37) s56))-[GOOD] (assert (= (table0 #x38) s57))-[GOOD] (assert (= (table0 #x39) s58))-[GOOD] (assert (= (table0 #x3a) s59))-[GOOD] (assert (= (table0 #x3b) s60))-[GOOD] (assert (= (table0 #x3c) s61))-[GOOD] (assert (= (table0 #x3d) s62))-[GOOD] (assert (= (table0 #x3e) s63))-[GOOD] (assert (= (table0 #x3f) s64))-[GOOD] (assert (= (table0 #x40) s65))-[GOOD] (assert (= (table0 #x41) s66))-[GOOD] (assert (= (table0 #x42) s67))-[GOOD] (assert (= (table0 #x43) s68))-[GOOD] (assert (= (table0 #x44) s69))-[GOOD] (assert (= (table0 #x45) s70))-[GOOD] (assert (= (table0 #x46) s71))-[GOOD] (assert (= (table0 #x47) s72))-[GOOD] (assert (= (table0 #x48) s73))-[GOOD] (assert (= (table0 #x49) s74))-[GOOD] (assert (= (table0 #x4a) s75))-[GOOD] (assert (= (table0 #x4b) s76))-[GOOD] (assert (= (table0 #x4c) s77))-[GOOD] (assert (= (table0 #x4d) s78))-[GOOD] (assert (= (table0 #x4e) s79))-[GOOD] (assert (= (table0 #x4f) s80))-[GOOD] (assert (= (table0 #x50) s81))-[GOOD] (assert (= (table0 #x51) s82))-[GOOD] (assert (= (table0 #x52) s83))-[GOOD] (assert (= (table0 #x53) s84))-[GOOD] (assert (= (table0 #x54) s85))-[GOOD] (assert (= (table0 #x55) s86))-[GOOD] (assert (= (table0 #x56) s87))-[GOOD] (assert (= (table0 #x57) s88))-[GOOD] (assert (= (table0 #x58) s89))-[GOOD] (assert (= (table0 #x59) s90))-[GOOD] (assert (= (table0 #x5a) s91))-[GOOD] (assert (= (table0 #x5b) s92))-[GOOD] (assert (= (table0 #x5c) s93))-[GOOD] (assert (= (table0 #x5d) s94))-[GOOD] (assert (= (table0 #x5e) s95))-[GOOD] (assert (= (table0 #x5f) s96))-[GOOD] (assert (= (table0 #x60) s97))-[GOOD] (assert (= (table0 #x61) s98))-[GOOD] (assert (= (table0 #x62) s99))-[GOOD] (assert (= (table0 #x63) s100))-[GOOD] (assert (= (table0 #x64) s101))-[GOOD] (assert (= (table0 #x65) s102))-[GOOD] (assert (= (table0 #x66) s103))-[GOOD] (assert (= (table0 #x67) s104))-[GOOD] (assert (= (table0 #x68) s105))-[GOOD] (assert (= (table0 #x69) s106))-[GOOD] (assert (= (table0 #x6a) s107))-[GOOD] (assert (= (table0 #x6b) s108))-[GOOD] (assert (= (table0 #x6c) s109))-[GOOD] (assert (= (table0 #x6d) s110))-[GOOD] (assert (= (table0 #x6e) s111))-[GOOD] (assert (= (table0 #x6f) s112))-[GOOD] (assert (= (table0 #x70) s113))-[GOOD] (assert (= (table0 #x71) s114))-[GOOD] (assert (= (table0 #x72) s115))-[GOOD] (assert (= (table0 #x73) s116))-[GOOD] (assert (= (table0 #x74) s117))-[GOOD] (assert (= (table0 #x75) s118))-[GOOD] (assert (= (table0 #x76) s119))-[GOOD] (assert (= (table0 #x77) s120))-[GOOD] (assert (= (table0 #x78) s121))-[GOOD] (assert (= (table0 #x79) s122))-[GOOD] (assert (= (table0 #x7a) s123))-[GOOD] (assert (= (table0 #x7b) s124))-[GOOD] (assert (= (table0 #x7c) s125))-[GOOD] (assert (= (table0 #x7d) s126))-[GOOD] (assert (= (table0 #x7e) s127))-[GOOD] (assert (= (table0 #x7f) s128))-[GOOD] (assert (= (table0 #x80) s129))-[GOOD] (assert (= (table0 #x81) s130))-[GOOD] (assert (= (table0 #x82) s131))-[GOOD] (assert (= (table0 #x83) s132))-[GOOD] (assert (= (table0 #x84) s133))-[GOOD] (assert (= (table0 #x85) s134))-[GOOD] (assert (= (table0 #x86) s135))-[GOOD] (assert (= (table0 #x87) s136))-[GOOD] (assert (= (table0 #x88) s137))-[GOOD] (assert (= (table0 #x89) s138))-[GOOD] (assert (= (table0 #x8a) s139))-[GOOD] (assert (= (table0 #x8b) s140))-[GOOD] (assert (= (table0 #x8c) s141))-[GOOD] (assert (= (table0 #x8d) s142))-[GOOD] (assert (= (table0 #x8e) s143))-[GOOD] (assert (= (table0 #x8f) s144))-[GOOD] (assert (= (table0 #x90) s145))-[GOOD] (assert (= (table0 #x91) s146))-[GOOD] (assert (= (table0 #x92) s147))-[GOOD] (assert (= (table0 #x93) s148))-[GOOD] (assert (= (table0 #x94) s149))-[GOOD] (assert (= (table0 #x95) s150))-[GOOD] (assert (= (table0 #x96) s151))-[GOOD] (assert (= (table0 #x97) s152))-[GOOD] (assert (= (table0 #x98) s153))-[GOOD] (assert (= (table0 #x99) s154))-[GOOD] (assert (= (table0 #x9a) s155))-[GOOD] (assert (= (table0 #x9b) s156))-[GOOD] (assert (= (table0 #x9c) s157))-[GOOD] (assert (= (table0 #x9d) s158))-[GOOD] (assert (= (table0 #x9e) s159))-[GOOD] (assert (= (table0 #x9f) s160))-[GOOD] (assert (= (table0 #xa0) s161))-[GOOD] (assert (= (table0 #xa1) s162))-[GOOD] (assert (= (table0 #xa2) s163))-[GOOD] (assert (= (table0 #xa3) s164))-[GOOD] (assert (= (table0 #xa4) s165))-[GOOD] (assert (= (table0 #xa5) s166))-[GOOD] (assert (= (table0 #xa6) s167))-[GOOD] (assert (= (table0 #xa7) s168))-[GOOD] (assert (= (table0 #xa8) s169))-[GOOD] (assert (= (table0 #xa9) s170))-[GOOD] (assert (= (table0 #xaa) s171))-[GOOD] (assert (= (table0 #xab) s172))-[GOOD] (assert (= (table0 #xac) s173))-[GOOD] (assert (= (table0 #xad) s174))-[GOOD] (assert (= (table0 #xae) s175))-[GOOD] (assert (= (table0 #xaf) s176))-[GOOD] (assert (= (table0 #xb0) s177))-[GOOD] (assert (= (table0 #xb1) s178))-[GOOD] (assert (= (table0 #xb2) s179))-[GOOD] (assert (= (table0 #xb3) s180))-[GOOD] (assert (= (table0 #xb4) s181))-[GOOD] (assert (= (table0 #xb5) s182))-[GOOD] (assert (= (table0 #xb6) s183))-[GOOD] (assert (= (table0 #xb7) s184))-[GOOD] (assert (= (table0 #xb8) s185))-[GOOD] (assert (= (table0 #xb9) s186))-[GOOD] (assert (= (table0 #xba) s187))-[GOOD] (assert (= (table0 #xbb) s188))-[GOOD] (assert (= (table0 #xbc) s189))-[GOOD] (assert (= (table0 #xbd) s190))-[GOOD] (assert (= (table0 #xbe) s191))-[GOOD] (assert (= (table0 #xbf) s192))-[GOOD] (assert (= (table0 #xc0) s193))-[GOOD] (assert (= (table0 #xc1) s194))-[GOOD] (assert (= (table0 #xc2) s195))-[GOOD] (assert (= (table0 #xc3) s196))-[GOOD] (assert (= (table0 #xc4) s197))-[GOOD] (assert (= (table0 #xc5) s198))-[GOOD] (assert (= (table0 #xc6) s199))-[GOOD] (assert (= (table0 #xc7) s200))-[GOOD] (assert (= (table0 #xc8) s201))-[GOOD] (assert (= (table0 #xc9) s202))-[GOOD] (assert (= (table0 #xca) s203))-[GOOD] (assert (= (table0 #xcb) s204))-[GOOD] (assert (= (table0 #xcc) s205))-[GOOD] (assert (= (table0 #xcd) s206))-[GOOD] (assert (= (table0 #xce) s207))-[GOOD] (assert (= (table0 #xcf) s208))-[GOOD] (assert (= (table0 #xd0) s209))-[GOOD] (assert (= (table0 #xd1) s210))-[GOOD] (assert (= (table0 #xd2) s211))-[GOOD] (assert (= (table0 #xd3) s212))-[GOOD] (assert (= (table0 #xd4) s213))-[GOOD] (assert (= (table0 #xd5) s214))-[GOOD] (assert (= (table0 #xd6) s215))-[GOOD] (assert (= (table0 #xd7) s216))-[GOOD] (assert (= (table0 #xd8) s217))-[GOOD] (assert (= (table0 #xd9) s218))-[GOOD] (assert (= (table0 #xda) s219))-[GOOD] (assert (= (table0 #xdb) s220))-[GOOD] (assert (= (table0 #xdc) s221))-[GOOD] (assert (= (table0 #xdd) s222))-[GOOD] (assert (= (table0 #xde) s223))-[GOOD] (assert (= (table0 #xdf) s224))-[GOOD] (assert (= (table0 #xe0) s225))-[GOOD] (assert (= (table0 #xe1) s226))-[GOOD] (assert (= (table0 #xe2) s227))-[GOOD] (assert (= (table0 #xe3) s228))-[GOOD] (assert (= (table0 #xe4) s229))-[GOOD] (assert (= (table0 #xe5) s230))-[GOOD] (assert (= (table0 #xe6) s231))-[GOOD] (assert (= (table0 #xe7) s232))-[GOOD] (assert (= (table0 #xe8) s233))-[GOOD] (assert (= (table0 #xe9) s234))-[GOOD] (assert (= (table0 #xea) s235))-[GOOD] (assert (= (table0 #xeb) s236))-[GOOD] (assert (= (table0 #xec) s237))-[GOOD] (assert (= (table0 #xed) s238))-[GOOD] (assert (= (table0 #xee) s239))-[GOOD] (assert (= (table0 #xef) s240))-[GOOD] (assert (= (table0 #xf0) s241))-[GOOD] (assert (= (table0 #xf1) s242))-[GOOD] (assert (= (table0 #xf2) s243))-[GOOD] (assert (= (table0 #xf3) s244))-[GOOD] (assert (= (table0 #xf4) s245))-[GOOD] (assert (= (table0 #xf5) s246))-[GOOD] (assert (= (table0 #xf6) s247))-[GOOD] (assert (= (table0 #xf7) s248))-[GOOD] (assert (= (table0 #xf8) s249))-[GOOD] (assert (= (table0 #xf9) s250))-[GOOD] (assert (= (table0 #xfa) s251))-[GOOD] (assert (= (table0 #xfb) s252))-[GOOD] (assert (= (table0 #xfc) s253))-[GOOD] (assert (= (table0 #xfd) s254))-[GOOD] (assert (= (table0 #xfe) s255))-[GOOD] (assert (= (table0 #xff) s256))+[GOOD] (define-fun table0_initializer_0 () Bool (= (table0 #x00) s1))+[GOOD] (define-fun table0_initializer_1 () Bool (= (table0 #x01) s2))+[GOOD] (define-fun table0_initializer_2 () Bool (= (table0 #x02) s3))+[GOOD] (define-fun table0_initializer_3 () Bool (= (table0 #x03) s4))+[GOOD] (define-fun table0_initializer_4 () Bool (= (table0 #x04) s5))+[GOOD] (define-fun table0_initializer_5 () Bool (= (table0 #x05) s6))+[GOOD] (define-fun table0_initializer_6 () Bool (= (table0 #x06) s7))+[GOOD] (define-fun table0_initializer_7 () Bool (= (table0 #x07) s8))+[GOOD] (define-fun table0_initializer_8 () Bool (= (table0 #x08) s9))+[GOOD] (define-fun table0_initializer_9 () Bool (= (table0 #x09) s10))+[GOOD] (define-fun table0_initializer_10 () Bool (= (table0 #x0a) s11))+[GOOD] (define-fun table0_initializer_11 () Bool (= (table0 #x0b) s12))+[GOOD] (define-fun table0_initializer_12 () Bool (= (table0 #x0c) s13))+[GOOD] (define-fun table0_initializer_13 () Bool (= (table0 #x0d) s14))+[GOOD] (define-fun table0_initializer_14 () Bool (= (table0 #x0e) s15))+[GOOD] (define-fun table0_initializer_15 () Bool (= (table0 #x0f) s16))+[GOOD] (define-fun table0_initializer_16 () Bool (= (table0 #x10) s17))+[GOOD] (define-fun table0_initializer_17 () Bool (= (table0 #x11) s18))+[GOOD] (define-fun table0_initializer_18 () Bool (= (table0 #x12) s19))+[GOOD] (define-fun table0_initializer_19 () Bool (= (table0 #x13) s20))+[GOOD] (define-fun table0_initializer_20 () Bool (= (table0 #x14) s21))+[GOOD] (define-fun table0_initializer_21 () Bool (= (table0 #x15) s22))+[GOOD] (define-fun table0_initializer_22 () Bool (= (table0 #x16) s23))+[GOOD] (define-fun table0_initializer_23 () Bool (= (table0 #x17) s24))+[GOOD] (define-fun table0_initializer_24 () Bool (= (table0 #x18) s25))+[GOOD] (define-fun table0_initializer_25 () Bool (= (table0 #x19) s26))+[GOOD] (define-fun table0_initializer_26 () Bool (= (table0 #x1a) s27))+[GOOD] (define-fun table0_initializer_27 () Bool (= (table0 #x1b) s28))+[GOOD] (define-fun table0_initializer_28 () Bool (= (table0 #x1c) s29))+[GOOD] (define-fun table0_initializer_29 () Bool (= (table0 #x1d) s30))+[GOOD] (define-fun table0_initializer_30 () Bool (= (table0 #x1e) s31))+[GOOD] (define-fun table0_initializer_31 () Bool (= (table0 #x1f) s32))+[GOOD] (define-fun table0_initializer_32 () Bool (= (table0 #x20) s33))+[GOOD] (define-fun table0_initializer_33 () Bool (= (table0 #x21) s34))+[GOOD] (define-fun table0_initializer_34 () Bool (= (table0 #x22) s35))+[GOOD] (define-fun table0_initializer_35 () Bool (= (table0 #x23) s36))+[GOOD] (define-fun table0_initializer_36 () Bool (= (table0 #x24) s37))+[GOOD] (define-fun table0_initializer_37 () Bool (= (table0 #x25) s38))+[GOOD] (define-fun table0_initializer_38 () Bool (= (table0 #x26) s39))+[GOOD] (define-fun table0_initializer_39 () Bool (= (table0 #x27) s40))+[GOOD] (define-fun table0_initializer_40 () Bool (= (table0 #x28) s41))+[GOOD] (define-fun table0_initializer_41 () Bool (= (table0 #x29) s42))+[GOOD] (define-fun table0_initializer_42 () Bool (= (table0 #x2a) s43))+[GOOD] (define-fun table0_initializer_43 () Bool (= (table0 #x2b) s44))+[GOOD] (define-fun table0_initializer_44 () Bool (= (table0 #x2c) s45))+[GOOD] (define-fun table0_initializer_45 () Bool (= (table0 #x2d) s46))+[GOOD] (define-fun table0_initializer_46 () Bool (= (table0 #x2e) s47))+[GOOD] (define-fun table0_initializer_47 () Bool (= (table0 #x2f) s48))+[GOOD] (define-fun table0_initializer_48 () Bool (= (table0 #x30) s49))+[GOOD] (define-fun table0_initializer_49 () Bool (= (table0 #x31) s50))+[GOOD] (define-fun table0_initializer_50 () Bool (= (table0 #x32) s51))+[GOOD] (define-fun table0_initializer_51 () Bool (= (table0 #x33) s52))+[GOOD] (define-fun table0_initializer_52 () Bool (= (table0 #x34) s53))+[GOOD] (define-fun table0_initializer_53 () Bool (= (table0 #x35) s54))+[GOOD] (define-fun table0_initializer_54 () Bool (= (table0 #x36) s55))+[GOOD] (define-fun table0_initializer_55 () Bool (= (table0 #x37) s56))+[GOOD] (define-fun table0_initializer_56 () Bool (= (table0 #x38) s57))+[GOOD] (define-fun table0_initializer_57 () Bool (= (table0 #x39) s58))+[GOOD] (define-fun table0_initializer_58 () Bool (= (table0 #x3a) s59))+[GOOD] (define-fun table0_initializer_59 () Bool (= (table0 #x3b) s60))+[GOOD] (define-fun table0_initializer_60 () Bool (= (table0 #x3c) s61))+[GOOD] (define-fun table0_initializer_61 () Bool (= (table0 #x3d) s62))+[GOOD] (define-fun table0_initializer_62 () Bool (= (table0 #x3e) s63))+[GOOD] (define-fun table0_initializer_63 () Bool (= (table0 #x3f) s64))+[GOOD] (define-fun table0_initializer_64 () Bool (= (table0 #x40) s65))+[GOOD] (define-fun table0_initializer_65 () Bool (= (table0 #x41) s66))+[GOOD] (define-fun table0_initializer_66 () Bool (= (table0 #x42) s67))+[GOOD] (define-fun table0_initializer_67 () Bool (= (table0 #x43) s68))+[GOOD] (define-fun table0_initializer_68 () Bool (= (table0 #x44) s69))+[GOOD] (define-fun table0_initializer_69 () Bool (= (table0 #x45) s70))+[GOOD] (define-fun table0_initializer_70 () Bool (= (table0 #x46) s71))+[GOOD] (define-fun table0_initializer_71 () Bool (= (table0 #x47) s72))+[GOOD] (define-fun table0_initializer_72 () Bool (= (table0 #x48) s73))+[GOOD] (define-fun table0_initializer_73 () Bool (= (table0 #x49) s74))+[GOOD] (define-fun table0_initializer_74 () Bool (= (table0 #x4a) s75))+[GOOD] (define-fun table0_initializer_75 () Bool (= (table0 #x4b) s76))+[GOOD] (define-fun table0_initializer_76 () Bool (= (table0 #x4c) s77))+[GOOD] (define-fun table0_initializer_77 () Bool (= (table0 #x4d) s78))+[GOOD] (define-fun table0_initializer_78 () Bool (= (table0 #x4e) s79))+[GOOD] (define-fun table0_initializer_79 () Bool (= (table0 #x4f) s80))+[GOOD] (define-fun table0_initializer_80 () Bool (= (table0 #x50) s81))+[GOOD] (define-fun table0_initializer_81 () Bool (= (table0 #x51) s82))+[GOOD] (define-fun table0_initializer_82 () Bool (= (table0 #x52) s83))+[GOOD] (define-fun table0_initializer_83 () Bool (= (table0 #x53) s84))+[GOOD] (define-fun table0_initializer_84 () Bool (= (table0 #x54) s85))+[GOOD] (define-fun table0_initializer_85 () Bool (= (table0 #x55) s86))+[GOOD] (define-fun table0_initializer_86 () Bool (= (table0 #x56) s87))+[GOOD] (define-fun table0_initializer_87 () Bool (= (table0 #x57) s88))+[GOOD] (define-fun table0_initializer_88 () Bool (= (table0 #x58) s89))+[GOOD] (define-fun table0_initializer_89 () Bool (= (table0 #x59) s90))+[GOOD] (define-fun table0_initializer_90 () Bool (= (table0 #x5a) s91))+[GOOD] (define-fun table0_initializer_91 () Bool (= (table0 #x5b) s92))+[GOOD] (define-fun table0_initializer_92 () Bool (= (table0 #x5c) s93))+[GOOD] (define-fun table0_initializer_93 () Bool (= (table0 #x5d) s94))+[GOOD] (define-fun table0_initializer_94 () Bool (= (table0 #x5e) s95))+[GOOD] (define-fun table0_initializer_95 () Bool (= (table0 #x5f) s96))+[GOOD] (define-fun table0_initializer_96 () Bool (= (table0 #x60) s97))+[GOOD] (define-fun table0_initializer_97 () Bool (= (table0 #x61) s98))+[GOOD] (define-fun table0_initializer_98 () Bool (= (table0 #x62) s99))+[GOOD] (define-fun table0_initializer_99 () Bool (= (table0 #x63) s100))+[GOOD] (define-fun table0_initializer_100 () Bool (= (table0 #x64) s101))+[GOOD] (define-fun table0_initializer_101 () Bool (= (table0 #x65) s102))+[GOOD] (define-fun table0_initializer_102 () Bool (= (table0 #x66) s103))+[GOOD] (define-fun table0_initializer_103 () Bool (= (table0 #x67) s104))+[GOOD] (define-fun table0_initializer_104 () Bool (= (table0 #x68) s105))+[GOOD] (define-fun table0_initializer_105 () Bool (= (table0 #x69) s106))+[GOOD] (define-fun table0_initializer_106 () Bool (= (table0 #x6a) s107))+[GOOD] (define-fun table0_initializer_107 () Bool (= (table0 #x6b) s108))+[GOOD] (define-fun table0_initializer_108 () Bool (= (table0 #x6c) s109))+[GOOD] (define-fun table0_initializer_109 () Bool (= (table0 #x6d) s110))+[GOOD] (define-fun table0_initializer_110 () Bool (= (table0 #x6e) s111))+[GOOD] (define-fun table0_initializer_111 () Bool (= (table0 #x6f) s112))+[GOOD] (define-fun table0_initializer_112 () Bool (= (table0 #x70) s113))+[GOOD] (define-fun table0_initializer_113 () Bool (= (table0 #x71) s114))+[GOOD] (define-fun table0_initializer_114 () Bool (= (table0 #x72) s115))+[GOOD] (define-fun table0_initializer_115 () Bool (= (table0 #x73) s116))+[GOOD] (define-fun table0_initializer_116 () Bool (= (table0 #x74) s117))+[GOOD] (define-fun table0_initializer_117 () Bool (= (table0 #x75) s118))+[GOOD] (define-fun table0_initializer_118 () Bool (= (table0 #x76) s119))+[GOOD] (define-fun table0_initializer_119 () Bool (= (table0 #x77) s120))+[GOOD] (define-fun table0_initializer_120 () Bool (= (table0 #x78) s121))+[GOOD] (define-fun table0_initializer_121 () Bool (= (table0 #x79) s122))+[GOOD] (define-fun table0_initializer_122 () Bool (= (table0 #x7a) s123))+[GOOD] (define-fun table0_initializer_123 () Bool (= (table0 #x7b) s124))+[GOOD] (define-fun table0_initializer_124 () Bool (= (table0 #x7c) s125))+[GOOD] (define-fun table0_initializer_125 () Bool (= (table0 #x7d) s126))+[GOOD] (define-fun table0_initializer_126 () Bool (= (table0 #x7e) s127))+[GOOD] (define-fun table0_initializer_127 () Bool (= (table0 #x7f) s128))+[GOOD] (define-fun table0_initializer_128 () Bool (= (table0 #x80) s129))+[GOOD] (define-fun table0_initializer_129 () Bool (= (table0 #x81) s130))+[GOOD] (define-fun table0_initializer_130 () Bool (= (table0 #x82) s131))+[GOOD] (define-fun table0_initializer_131 () Bool (= (table0 #x83) s132))+[GOOD] (define-fun table0_initializer_132 () Bool (= (table0 #x84) s133))+[GOOD] (define-fun table0_initializer_133 () Bool (= (table0 #x85) s134))+[GOOD] (define-fun table0_initializer_134 () Bool (= (table0 #x86) s135))+[GOOD] (define-fun table0_initializer_135 () Bool (= (table0 #x87) s136))+[GOOD] (define-fun table0_initializer_136 () Bool (= (table0 #x88) s137))+[GOOD] (define-fun table0_initializer_137 () Bool (= (table0 #x89) s138))+[GOOD] (define-fun table0_initializer_138 () Bool (= (table0 #x8a) s139))+[GOOD] (define-fun table0_initializer_139 () Bool (= (table0 #x8b) s140))+[GOOD] (define-fun table0_initializer_140 () Bool (= (table0 #x8c) s141))+[GOOD] (define-fun table0_initializer_141 () Bool (= (table0 #x8d) s142))+[GOOD] (define-fun table0_initializer_142 () Bool (= (table0 #x8e) s143))+[GOOD] (define-fun table0_initializer_143 () Bool (= (table0 #x8f) s144))+[GOOD] (define-fun table0_initializer_144 () Bool (= (table0 #x90) s145))+[GOOD] (define-fun table0_initializer_145 () Bool (= (table0 #x91) s146))+[GOOD] (define-fun table0_initializer_146 () Bool (= (table0 #x92) s147))+[GOOD] (define-fun table0_initializer_147 () Bool (= (table0 #x93) s148))+[GOOD] (define-fun table0_initializer_148 () Bool (= (table0 #x94) s149))+[GOOD] (define-fun table0_initializer_149 () Bool (= (table0 #x95) s150))+[GOOD] (define-fun table0_initializer_150 () Bool (= (table0 #x96) s151))+[GOOD] (define-fun table0_initializer_151 () Bool (= (table0 #x97) s152))+[GOOD] (define-fun table0_initializer_152 () Bool (= (table0 #x98) s153))+[GOOD] (define-fun table0_initializer_153 () Bool (= (table0 #x99) s154))+[GOOD] (define-fun table0_initializer_154 () Bool (= (table0 #x9a) s155))+[GOOD] (define-fun table0_initializer_155 () Bool (= (table0 #x9b) s156))+[GOOD] (define-fun table0_initializer_156 () Bool (= (table0 #x9c) s157))+[GOOD] (define-fun table0_initializer_157 () Bool (= (table0 #x9d) s158))+[GOOD] (define-fun table0_initializer_158 () Bool (= (table0 #x9e) s159))+[GOOD] (define-fun table0_initializer_159 () Bool (= (table0 #x9f) s160))+[GOOD] (define-fun table0_initializer_160 () Bool (= (table0 #xa0) s161))+[GOOD] (define-fun table0_initializer_161 () Bool (= (table0 #xa1) s162))+[GOOD] (define-fun table0_initializer_162 () Bool (= (table0 #xa2) s163))+[GOOD] (define-fun table0_initializer_163 () Bool (= (table0 #xa3) s164))+[GOOD] (define-fun table0_initializer_164 () Bool (= (table0 #xa4) s165))+[GOOD] (define-fun table0_initializer_165 () Bool (= (table0 #xa5) s166))+[GOOD] (define-fun table0_initializer_166 () Bool (= (table0 #xa6) s167))+[GOOD] (define-fun table0_initializer_167 () Bool (= (table0 #xa7) s168))+[GOOD] (define-fun table0_initializer_168 () Bool (= (table0 #xa8) s169))+[GOOD] (define-fun table0_initializer_169 () Bool (= (table0 #xa9) s170))+[GOOD] (define-fun table0_initializer_170 () Bool (= (table0 #xaa) s171))+[GOOD] (define-fun table0_initializer_171 () Bool (= (table0 #xab) s172))+[GOOD] (define-fun table0_initializer_172 () Bool (= (table0 #xac) s173))+[GOOD] (define-fun table0_initializer_173 () Bool (= (table0 #xad) s174))+[GOOD] (define-fun table0_initializer_174 () Bool (= (table0 #xae) s175))+[GOOD] (define-fun table0_initializer_175 () Bool (= (table0 #xaf) s176))+[GOOD] (define-fun table0_initializer_176 () Bool (= (table0 #xb0) s177))+[GOOD] (define-fun table0_initializer_177 () Bool (= (table0 #xb1) s178))+[GOOD] (define-fun table0_initializer_178 () Bool (= (table0 #xb2) s179))+[GOOD] (define-fun table0_initializer_179 () Bool (= (table0 #xb3) s180))+[GOOD] (define-fun table0_initializer_180 () Bool (= (table0 #xb4) s181))+[GOOD] (define-fun table0_initializer_181 () Bool (= (table0 #xb5) s182))+[GOOD] (define-fun table0_initializer_182 () Bool (= (table0 #xb6) s183))+[GOOD] (define-fun table0_initializer_183 () Bool (= (table0 #xb7) s184))+[GOOD] (define-fun table0_initializer_184 () Bool (= (table0 #xb8) s185))+[GOOD] (define-fun table0_initializer_185 () Bool (= (table0 #xb9) s186))+[GOOD] (define-fun table0_initializer_186 () Bool (= (table0 #xba) s187))+[GOOD] (define-fun table0_initializer_187 () Bool (= (table0 #xbb) s188))+[GOOD] (define-fun table0_initializer_188 () Bool (= (table0 #xbc) s189))+[GOOD] (define-fun table0_initializer_189 () Bool (= (table0 #xbd) s190))+[GOOD] (define-fun table0_initializer_190 () Bool (= (table0 #xbe) s191))+[GOOD] (define-fun table0_initializer_191 () Bool (= (table0 #xbf) s192))+[GOOD] (define-fun table0_initializer_192 () Bool (= (table0 #xc0) s193))+[GOOD] (define-fun table0_initializer_193 () Bool (= (table0 #xc1) s194))+[GOOD] (define-fun table0_initializer_194 () Bool (= (table0 #xc2) s195))+[GOOD] (define-fun table0_initializer_195 () Bool (= (table0 #xc3) s196))+[GOOD] (define-fun table0_initializer_196 () Bool (= (table0 #xc4) s197))+[GOOD] (define-fun table0_initializer_197 () Bool (= (table0 #xc5) s198))+[GOOD] (define-fun table0_initializer_198 () Bool (= (table0 #xc6) s199))+[GOOD] (define-fun table0_initializer_199 () Bool (= (table0 #xc7) s200))+[GOOD] (define-fun table0_initializer_200 () Bool (= (table0 #xc8) s201))+[GOOD] (define-fun table0_initializer_201 () Bool (= (table0 #xc9) s202))+[GOOD] (define-fun table0_initializer_202 () Bool (= (table0 #xca) s203))+[GOOD] (define-fun table0_initializer_203 () Bool (= (table0 #xcb) s204))+[GOOD] (define-fun table0_initializer_204 () Bool (= (table0 #xcc) s205))+[GOOD] (define-fun table0_initializer_205 () Bool (= (table0 #xcd) s206))+[GOOD] (define-fun table0_initializer_206 () Bool (= (table0 #xce) s207))+[GOOD] (define-fun table0_initializer_207 () Bool (= (table0 #xcf) s208))+[GOOD] (define-fun table0_initializer_208 () Bool (= (table0 #xd0) s209))+[GOOD] (define-fun table0_initializer_209 () Bool (= (table0 #xd1) s210))+[GOOD] (define-fun table0_initializer_210 () Bool (= (table0 #xd2) s211))+[GOOD] (define-fun table0_initializer_211 () Bool (= (table0 #xd3) s212))+[GOOD] (define-fun table0_initializer_212 () Bool (= (table0 #xd4) s213))+[GOOD] (define-fun table0_initializer_213 () Bool (= (table0 #xd5) s214))+[GOOD] (define-fun table0_initializer_214 () Bool (= (table0 #xd6) s215))+[GOOD] (define-fun table0_initializer_215 () Bool (= (table0 #xd7) s216))+[GOOD] (define-fun table0_initializer_216 () Bool (= (table0 #xd8) s217))+[GOOD] (define-fun table0_initializer_217 () Bool (= (table0 #xd9) s218))+[GOOD] (define-fun table0_initializer_218 () Bool (= (table0 #xda) s219))+[GOOD] (define-fun table0_initializer_219 () Bool (= (table0 #xdb) s220))+[GOOD] (define-fun table0_initializer_220 () Bool (= (table0 #xdc) s221))+[GOOD] (define-fun table0_initializer_221 () Bool (= (table0 #xdd) s222))+[GOOD] (define-fun table0_initializer_222 () Bool (= (table0 #xde) s223))+[GOOD] (define-fun table0_initializer_223 () Bool (= (table0 #xdf) s224))+[GOOD] (define-fun table0_initializer_224 () Bool (= (table0 #xe0) s225))+[GOOD] (define-fun table0_initializer_225 () Bool (= (table0 #xe1) s226))+[GOOD] (define-fun table0_initializer_226 () Bool (= (table0 #xe2) s227))+[GOOD] (define-fun table0_initializer_227 () Bool (= (table0 #xe3) s228))+[GOOD] (define-fun table0_initializer_228 () Bool (= (table0 #xe4) s229))+[GOOD] (define-fun table0_initializer_229 () Bool (= (table0 #xe5) s230))+[GOOD] (define-fun table0_initializer_230 () Bool (= (table0 #xe6) s231))+[GOOD] (define-fun table0_initializer_231 () Bool (= (table0 #xe7) s232))+[GOOD] (define-fun table0_initializer_232 () Bool (= (table0 #xe8) s233))+[GOOD] (define-fun table0_initializer_233 () Bool (= (table0 #xe9) s234))+[GOOD] (define-fun table0_initializer_234 () Bool (= (table0 #xea) s235))+[GOOD] (define-fun table0_initializer_235 () Bool (= (table0 #xeb) s236))+[GOOD] (define-fun table0_initializer_236 () Bool (= (table0 #xec) s237))+[GOOD] (define-fun table0_initializer_237 () Bool (= (table0 #xed) s238))+[GOOD] (define-fun table0_initializer_238 () Bool (= (table0 #xee) s239))+[GOOD] (define-fun table0_initializer_239 () Bool (= (table0 #xef) s240))+[GOOD] (define-fun table0_initializer_240 () Bool (= (table0 #xf0) s241))+[GOOD] (define-fun table0_initializer_241 () Bool (= (table0 #xf1) s242))+[GOOD] (define-fun table0_initializer_242 () Bool (= (table0 #xf2) s243))+[GOOD] (define-fun table0_initializer_243 () Bool (= (table0 #xf3) s244))+[GOOD] (define-fun table0_initializer_244 () Bool (= (table0 #xf4) s245))+[GOOD] (define-fun table0_initializer_245 () Bool (= (table0 #xf5) s246))+[GOOD] (define-fun table0_initializer_246 () Bool (= (table0 #xf6) s247))+[GOOD] (define-fun table0_initializer_247 () Bool (= (table0 #xf7) s248))+[GOOD] (define-fun table0_initializer_248 () Bool (= (table0 #xf8) s249))+[GOOD] (define-fun table0_initializer_249 () Bool (= (table0 #xf9) s250))+[GOOD] (define-fun table0_initializer_250 () Bool (= (table0 #xfa) s251))+[GOOD] (define-fun table0_initializer_251 () Bool (= (table0 #xfb) s252))+[GOOD] (define-fun table0_initializer_252 () Bool (= (table0 #xfc) s253))+[GOOD] (define-fun table0_initializer_253 () Bool (= (table0 #xfd) s254))+[GOOD] (define-fun table0_initializer_254 () Bool (= (table0 #xfe) s255))+[GOOD] (define-fun table0_initializer_255 () Bool (= (table0 #xff) s256))+[GOOD] (define-fun table0_initializer () Bool (and table0_initializer_0 table0_initializer_1 table0_initializer_2 table0_initializer_3 table0_initializer_4 table0_initializer_5 table0_initializer_6 table0_initializer_7 table0_initializer_8 table0_initializer_9 table0_initializer_10 table0_initializer_11 table0_initializer_12 table0_initializer_13 table0_initializer_14 table0_initializer_15 table0_initializer_16 table0_initializer_17 table0_initializer_18 table0_initializer_19 table0_initializer_20 table0_initializer_21 table0_initializer_22 table0_initializer_23 table0_initializer_24 table0_initializer_25 table0_initializer_26 table0_initializer_27 table0_initializer_28 table0_initializer_29 table0_initializer_30 table0_initializer_31 table0_initializer_32 table0_initializer_33 table0_initializer_34 table0_initializer_35 table0_initializer_36 table0_initializer_37 table0_initializer_38 table0_initializer_39 table0_initializer_40 table0_initializer_41 table0_initializer_42 table0_initializer_43 table0_initializer_44 table0_initializer_45 table0_initializer_46 table0_initializer_47 table0_initializer_48 table0_initializer_49 table0_initializer_50 table0_initializer_51 table0_initializer_52 table0_initializer_53 table0_initializer_54 table0_initializer_55 table0_initializer_56 table0_initializer_57 table0_initializer_58 table0_initializer_59 table0_initializer_60 table0_initializer_61 table0_initializer_62 table0_initializer_63 table0_initializer_64 table0_initializer_65 table0_initializer_66 table0_initializer_67 table0_initializer_68 table0_initializer_69 table0_initializer_70 table0_initializer_71 table0_initializer_72 table0_initializer_73 table0_initializer_74 table0_initializer_75 table0_initializer_76 table0_initializer_77 table0_initializer_78 table0_initializer_79 table0_initializer_80 table0_initializer_81 table0_initializer_82 table0_initializer_83 table0_initializer_84 table0_initializer_85 table0_initializer_86 table0_initializer_87 table0_initializer_88 table0_initializer_89 table0_initializer_90 table0_initializer_91 table0_initializer_92 table0_initializer_93 table0_initializer_94 table0_initializer_95 table0_initializer_96 table0_initializer_97 table0_initializer_98 table0_initializer_99 table0_initializer_100 table0_initializer_101 table0_initializer_102 table0_initializer_103 table0_initializer_104 table0_initializer_105 table0_initializer_106 table0_initializer_107 table0_initializer_108 table0_initializer_109 table0_initializer_110 table0_initializer_111 table0_initializer_112 table0_initializer_113 table0_initializer_114 table0_initializer_115 table0_initializer_116 table0_initializer_117 table0_initializer_118 table0_initializer_119 table0_initializer_120 table0_initializer_121 table0_initializer_122 table0_initializer_123 table0_initializer_124 table0_initializer_125 table0_initializer_126 table0_initializer_127 table0_initializer_128 table0_initializer_129 table0_initializer_130 table0_initializer_131 table0_initializer_132 table0_initializer_133 table0_initializer_134 table0_initializer_135 table0_initializer_136 table0_initializer_137 table0_initializer_138 table0_initializer_139 table0_initializer_140 table0_initializer_141 table0_initializer_142 table0_initializer_143 table0_initializer_144 table0_initializer_145 table0_initializer_146 table0_initializer_147 table0_initializer_148 table0_initializer_149 table0_initializer_150 table0_initializer_151 table0_initializer_152 table0_initializer_153 table0_initializer_154 table0_initializer_155 table0_initializer_156 table0_initializer_157 table0_initializer_158 table0_initializer_159 table0_initializer_160 table0_initializer_161 table0_initializer_162 table0_initializer_163 table0_initializer_164 table0_initializer_165 table0_initializer_166 table0_initializer_167 table0_initializer_168 table0_initializer_169 table0_initializer_170 table0_initializer_171 table0_initializer_172 table0_initializer_173 table0_initializer_174 table0_initializer_175 table0_initializer_176 table0_initializer_177 table0_initializer_178 table0_initializer_179 table0_initializer_180 table0_initializer_181 table0_initializer_182 table0_initializer_183 table0_initializer_184 table0_initializer_185 table0_initializer_186 table0_initializer_187 table0_initializer_188 table0_initializer_189 table0_initializer_190 table0_initializer_191 table0_initializer_192 table0_initializer_193 table0_initializer_194 table0_initializer_195 table0_initializer_196 table0_initializer_197 table0_initializer_198 table0_initializer_199 table0_initializer_200 table0_initializer_201 table0_initializer_202 table0_initializer_203 table0_initializer_204 table0_initializer_205 table0_initializer_206 table0_initializer_207 table0_initializer_208 table0_initializer_209 table0_initializer_210 table0_initializer_211 table0_initializer_212 table0_initializer_213 table0_initializer_214 table0_initializer_215 table0_initializer_216 table0_initializer_217 table0_initializer_218 table0_initializer_219 table0_initializer_220 table0_initializer_221 table0_initializer_222 table0_initializer_223 table0_initializer_224 table0_initializer_225 table0_initializer_226 table0_initializer_227 table0_initializer_228 table0_initializer_229 table0_initializer_230 table0_initializer_231 table0_initializer_232 table0_initializer_233 table0_initializer_234 table0_initializer_235 table0_initializer_236 table0_initializer_237 table0_initializer_238 table0_initializer_239 table0_initializer_240 table0_initializer_241 table0_initializer_242 table0_initializer_243 table0_initializer_244 table0_initializer_245 table0_initializer_246 table0_initializer_247 table0_initializer_248 table0_initializer_249 table0_initializer_250 table0_initializer_251 table0_initializer_252 table0_initializer_253 table0_initializer_254 table0_initializer_255))+[GOOD] (assert table0_initializer) [GOOD] (define-fun s257 () (_ BitVec 8) (table0 s0)) [GOOD] (define-fun s258 () Bool (= s0 s257)) [GOOD] (assert s258)
SBVTestSuite/GoldFiles/queryArrays3.gold view
@@ -20,262 +20,264 @@ [GOOD] ; --- formula --- [GOOD] (define-fun s1 () (_ BitVec 8) #x00) [GOOD] (declare-fun table0 ((_ BitVec 8)) (_ BitVec 8))-[GOOD] (assert (= (table0 #x00) s0))-[GOOD] (assert (= (table0 #x01) s0))-[GOOD] (assert (= (table0 #x02) s0))-[GOOD] (assert (= (table0 #x03) s0))-[GOOD] (assert (= (table0 #x04) s0))-[GOOD] (assert (= (table0 #x05) s0))-[GOOD] (assert (= (table0 #x06) s0))-[GOOD] (assert (= (table0 #x07) s0))-[GOOD] (assert (= (table0 #x08) s0))-[GOOD] (assert (= (table0 #x09) s0))-[GOOD] (assert (= (table0 #x0a) s0))-[GOOD] (assert (= (table0 #x0b) s0))-[GOOD] (assert (= (table0 #x0c) s0))-[GOOD] (assert (= (table0 #x0d) s0))-[GOOD] (assert (= (table0 #x0e) s0))-[GOOD] (assert (= (table0 #x0f) s0))-[GOOD] (assert (= (table0 #x10) s0))-[GOOD] (assert (= (table0 #x11) s0))-[GOOD] (assert (= (table0 #x12) s0))-[GOOD] (assert (= (table0 #x13) s0))-[GOOD] (assert (= (table0 #x14) s0))-[GOOD] (assert (= (table0 #x15) s0))-[GOOD] (assert (= (table0 #x16) s0))-[GOOD] (assert (= (table0 #x17) s0))-[GOOD] (assert (= (table0 #x18) s0))-[GOOD] (assert (= (table0 #x19) s0))-[GOOD] (assert (= (table0 #x1a) s0))-[GOOD] (assert (= (table0 #x1b) s0))-[GOOD] (assert (= (table0 #x1c) s0))-[GOOD] (assert (= (table0 #x1d) s0))-[GOOD] (assert (= (table0 #x1e) s0))-[GOOD] (assert (= (table0 #x1f) s0))-[GOOD] (assert (= (table0 #x20) s0))-[GOOD] (assert (= (table0 #x21) s0))-[GOOD] (assert (= (table0 #x22) s0))-[GOOD] (assert (= (table0 #x23) s0))-[GOOD] (assert (= (table0 #x24) s0))-[GOOD] (assert (= (table0 #x25) s0))-[GOOD] (assert (= (table0 #x26) s0))-[GOOD] (assert (= (table0 #x27) s0))-[GOOD] (assert (= (table0 #x28) s0))-[GOOD] (assert (= (table0 #x29) s0))-[GOOD] (assert (= (table0 #x2a) s0))-[GOOD] (assert (= (table0 #x2b) s0))-[GOOD] (assert (= (table0 #x2c) s0))-[GOOD] (assert (= (table0 #x2d) s0))-[GOOD] (assert (= (table0 #x2e) s0))-[GOOD] (assert (= (table0 #x2f) s0))-[GOOD] (assert (= (table0 #x30) s0))-[GOOD] (assert (= (table0 #x31) s0))-[GOOD] (assert (= (table0 #x32) s0))-[GOOD] (assert (= (table0 #x33) s0))-[GOOD] (assert (= (table0 #x34) s0))-[GOOD] (assert (= (table0 #x35) s0))-[GOOD] (assert (= (table0 #x36) s0))-[GOOD] (assert (= (table0 #x37) s0))-[GOOD] (assert (= (table0 #x38) s0))-[GOOD] (assert (= (table0 #x39) s0))-[GOOD] (assert (= (table0 #x3a) s0))-[GOOD] (assert (= (table0 #x3b) s0))-[GOOD] (assert (= (table0 #x3c) s0))-[GOOD] (assert (= (table0 #x3d) s0))-[GOOD] (assert (= (table0 #x3e) s0))-[GOOD] (assert (= (table0 #x3f) s0))-[GOOD] (assert (= (table0 #x40) s0))-[GOOD] (assert (= (table0 #x41) s0))-[GOOD] (assert (= (table0 #x42) s0))-[GOOD] (assert (= (table0 #x43) s0))-[GOOD] (assert (= (table0 #x44) s0))-[GOOD] (assert (= (table0 #x45) s0))-[GOOD] (assert (= (table0 #x46) s0))-[GOOD] (assert (= (table0 #x47) s0))-[GOOD] (assert (= (table0 #x48) s0))-[GOOD] (assert (= (table0 #x49) s0))-[GOOD] (assert (= (table0 #x4a) s0))-[GOOD] (assert (= (table0 #x4b) s0))-[GOOD] (assert (= (table0 #x4c) s0))-[GOOD] (assert (= (table0 #x4d) s0))-[GOOD] (assert (= (table0 #x4e) s0))-[GOOD] (assert (= (table0 #x4f) s0))-[GOOD] (assert (= (table0 #x50) s0))-[GOOD] (assert (= (table0 #x51) s0))-[GOOD] (assert (= (table0 #x52) s0))-[GOOD] (assert (= (table0 #x53) s0))-[GOOD] (assert (= (table0 #x54) s0))-[GOOD] (assert (= (table0 #x55) s0))-[GOOD] (assert (= (table0 #x56) s0))-[GOOD] (assert (= (table0 #x57) s0))-[GOOD] (assert (= (table0 #x58) s0))-[GOOD] (assert (= (table0 #x59) s0))-[GOOD] (assert (= (table0 #x5a) s0))-[GOOD] (assert (= (table0 #x5b) s0))-[GOOD] (assert (= (table0 #x5c) s0))-[GOOD] (assert (= (table0 #x5d) s0))-[GOOD] (assert (= (table0 #x5e) s0))-[GOOD] (assert (= (table0 #x5f) s0))-[GOOD] (assert (= (table0 #x60) s0))-[GOOD] (assert (= (table0 #x61) s0))-[GOOD] (assert (= (table0 #x62) s0))-[GOOD] (assert (= (table0 #x63) s0))-[GOOD] (assert (= (table0 #x64) s0))-[GOOD] (assert (= (table0 #x65) s0))-[GOOD] (assert (= (table0 #x66) s0))-[GOOD] (assert (= (table0 #x67) s0))-[GOOD] (assert (= (table0 #x68) s0))-[GOOD] (assert (= (table0 #x69) s0))-[GOOD] (assert (= (table0 #x6a) s0))-[GOOD] (assert (= (table0 #x6b) s0))-[GOOD] (assert (= (table0 #x6c) s0))-[GOOD] (assert (= (table0 #x6d) s0))-[GOOD] (assert (= (table0 #x6e) s0))-[GOOD] (assert (= (table0 #x6f) s0))-[GOOD] (assert (= (table0 #x70) s0))-[GOOD] (assert (= (table0 #x71) s0))-[GOOD] (assert (= (table0 #x72) s0))-[GOOD] (assert (= (table0 #x73) s0))-[GOOD] (assert (= (table0 #x74) s0))-[GOOD] (assert (= (table0 #x75) s0))-[GOOD] (assert (= (table0 #x76) s0))-[GOOD] (assert (= (table0 #x77) s0))-[GOOD] (assert (= (table0 #x78) s0))-[GOOD] (assert (= (table0 #x79) s0))-[GOOD] (assert (= (table0 #x7a) s0))-[GOOD] (assert (= (table0 #x7b) s0))-[GOOD] (assert (= (table0 #x7c) s0))-[GOOD] (assert (= (table0 #x7d) s0))-[GOOD] (assert (= (table0 #x7e) s0))-[GOOD] (assert (= (table0 #x7f) s0))-[GOOD] (assert (= (table0 #x80) s0))-[GOOD] (assert (= (table0 #x81) s0))-[GOOD] (assert (= (table0 #x82) s0))-[GOOD] (assert (= (table0 #x83) s0))-[GOOD] (assert (= (table0 #x84) s0))-[GOOD] (assert (= (table0 #x85) s0))-[GOOD] (assert (= (table0 #x86) s0))-[GOOD] (assert (= (table0 #x87) s0))-[GOOD] (assert (= (table0 #x88) s0))-[GOOD] (assert (= (table0 #x89) s0))-[GOOD] (assert (= (table0 #x8a) s0))-[GOOD] (assert (= (table0 #x8b) s0))-[GOOD] (assert (= (table0 #x8c) s0))-[GOOD] (assert (= (table0 #x8d) s0))-[GOOD] (assert (= (table0 #x8e) s0))-[GOOD] (assert (= (table0 #x8f) s0))-[GOOD] (assert (= (table0 #x90) s0))-[GOOD] (assert (= (table0 #x91) s0))-[GOOD] (assert (= (table0 #x92) s0))-[GOOD] (assert (= (table0 #x93) s0))-[GOOD] (assert (= (table0 #x94) s0))-[GOOD] (assert (= (table0 #x95) s0))-[GOOD] (assert (= (table0 #x96) s0))-[GOOD] (assert (= (table0 #x97) s0))-[GOOD] (assert (= (table0 #x98) s0))-[GOOD] (assert (= (table0 #x99) s0))-[GOOD] (assert (= (table0 #x9a) s0))-[GOOD] (assert (= (table0 #x9b) s0))-[GOOD] (assert (= (table0 #x9c) s0))-[GOOD] (assert (= (table0 #x9d) s0))-[GOOD] (assert (= (table0 #x9e) s0))-[GOOD] (assert (= (table0 #x9f) s0))-[GOOD] (assert (= (table0 #xa0) s0))-[GOOD] (assert (= (table0 #xa1) s0))-[GOOD] (assert (= (table0 #xa2) s0))-[GOOD] (assert (= (table0 #xa3) s0))-[GOOD] (assert (= (table0 #xa4) s0))-[GOOD] (assert (= (table0 #xa5) s0))-[GOOD] (assert (= (table0 #xa6) s0))-[GOOD] (assert (= (table0 #xa7) s0))-[GOOD] (assert (= (table0 #xa8) s0))-[GOOD] (assert (= (table0 #xa9) s0))-[GOOD] (assert (= (table0 #xaa) s0))-[GOOD] (assert (= (table0 #xab) s0))-[GOOD] (assert (= (table0 #xac) s0))-[GOOD] (assert (= (table0 #xad) s0))-[GOOD] (assert (= (table0 #xae) s0))-[GOOD] (assert (= (table0 #xaf) s0))-[GOOD] (assert (= (table0 #xb0) s0))-[GOOD] (assert (= (table0 #xb1) s0))-[GOOD] (assert (= (table0 #xb2) s0))-[GOOD] (assert (= (table0 #xb3) s0))-[GOOD] (assert (= (table0 #xb4) s0))-[GOOD] (assert (= (table0 #xb5) s0))-[GOOD] (assert (= (table0 #xb6) s0))-[GOOD] (assert (= (table0 #xb7) s0))-[GOOD] (assert (= (table0 #xb8) s0))-[GOOD] (assert (= (table0 #xb9) s0))-[GOOD] (assert (= (table0 #xba) s0))-[GOOD] (assert (= (table0 #xbb) s0))-[GOOD] (assert (= (table0 #xbc) s0))-[GOOD] (assert (= (table0 #xbd) s0))-[GOOD] (assert (= (table0 #xbe) s0))-[GOOD] (assert (= (table0 #xbf) s0))-[GOOD] (assert (= (table0 #xc0) s0))-[GOOD] (assert (= (table0 #xc1) s0))-[GOOD] (assert (= (table0 #xc2) s0))-[GOOD] (assert (= (table0 #xc3) s0))-[GOOD] (assert (= (table0 #xc4) s0))-[GOOD] (assert (= (table0 #xc5) s0))-[GOOD] (assert (= (table0 #xc6) s0))-[GOOD] (assert (= (table0 #xc7) s0))-[GOOD] (assert (= (table0 #xc8) s0))-[GOOD] (assert (= (table0 #xc9) s0))-[GOOD] (assert (= (table0 #xca) s0))-[GOOD] (assert (= (table0 #xcb) s0))-[GOOD] (assert (= (table0 #xcc) s0))-[GOOD] (assert (= (table0 #xcd) s0))-[GOOD] (assert (= (table0 #xce) s0))-[GOOD] (assert (= (table0 #xcf) s0))-[GOOD] (assert (= (table0 #xd0) s0))-[GOOD] (assert (= (table0 #xd1) s0))-[GOOD] (assert (= (table0 #xd2) s0))-[GOOD] (assert (= (table0 #xd3) s0))-[GOOD] (assert (= (table0 #xd4) s0))-[GOOD] (assert (= (table0 #xd5) s0))-[GOOD] (assert (= (table0 #xd6) s0))-[GOOD] (assert (= (table0 #xd7) s0))-[GOOD] (assert (= (table0 #xd8) s0))-[GOOD] (assert (= (table0 #xd9) s0))-[GOOD] (assert (= (table0 #xda) s0))-[GOOD] (assert (= (table0 #xdb) s0))-[GOOD] (assert (= (table0 #xdc) s0))-[GOOD] (assert (= (table0 #xdd) s0))-[GOOD] (assert (= (table0 #xde) s0))-[GOOD] (assert (= (table0 #xdf) s0))-[GOOD] (assert (= (table0 #xe0) s0))-[GOOD] (assert (= (table0 #xe1) s0))-[GOOD] (assert (= (table0 #xe2) s0))-[GOOD] (assert (= (table0 #xe3) s0))-[GOOD] (assert (= (table0 #xe4) s0))-[GOOD] (assert (= (table0 #xe5) s0))-[GOOD] (assert (= (table0 #xe6) s0))-[GOOD] (assert (= (table0 #xe7) s0))-[GOOD] (assert (= (table0 #xe8) s0))-[GOOD] (assert (= (table0 #xe9) s0))-[GOOD] (assert (= (table0 #xea) s0))-[GOOD] (assert (= (table0 #xeb) s0))-[GOOD] (assert (= (table0 #xec) s0))-[GOOD] (assert (= (table0 #xed) s0))-[GOOD] (assert (= (table0 #xee) s0))-[GOOD] (assert (= (table0 #xef) s0))-[GOOD] (assert (= (table0 #xf0) s0))-[GOOD] (assert (= (table0 #xf1) s0))-[GOOD] (assert (= (table0 #xf2) s0))-[GOOD] (assert (= (table0 #xf3) s0))-[GOOD] (assert (= (table0 #xf4) s0))-[GOOD] (assert (= (table0 #xf5) s0))-[GOOD] (assert (= (table0 #xf6) s0))-[GOOD] (assert (= (table0 #xf7) s0))-[GOOD] (assert (= (table0 #xf8) s0))-[GOOD] (assert (= (table0 #xf9) s0))-[GOOD] (assert (= (table0 #xfa) s0))-[GOOD] (assert (= (table0 #xfb) s0))-[GOOD] (assert (= (table0 #xfc) s0))-[GOOD] (assert (= (table0 #xfd) s0))-[GOOD] (assert (= (table0 #xfe) s0))-[GOOD] (assert (= (table0 #xff) s0))+[GOOD] (define-fun table0_initializer_0 () Bool (= (table0 #x00) s0))+[GOOD] (define-fun table0_initializer_1 () Bool (= (table0 #x01) s0))+[GOOD] (define-fun table0_initializer_2 () Bool (= (table0 #x02) s0))+[GOOD] (define-fun table0_initializer_3 () Bool (= (table0 #x03) s0))+[GOOD] (define-fun table0_initializer_4 () Bool (= (table0 #x04) s0))+[GOOD] (define-fun table0_initializer_5 () Bool (= (table0 #x05) s0))+[GOOD] (define-fun table0_initializer_6 () Bool (= (table0 #x06) s0))+[GOOD] (define-fun table0_initializer_7 () Bool (= (table0 #x07) s0))+[GOOD] (define-fun table0_initializer_8 () Bool (= (table0 #x08) s0))+[GOOD] (define-fun table0_initializer_9 () Bool (= (table0 #x09) s0))+[GOOD] (define-fun table0_initializer_10 () Bool (= (table0 #x0a) s0))+[GOOD] (define-fun table0_initializer_11 () Bool (= (table0 #x0b) s0))+[GOOD] (define-fun table0_initializer_12 () Bool (= (table0 #x0c) s0))+[GOOD] (define-fun table0_initializer_13 () Bool (= (table0 #x0d) s0))+[GOOD] (define-fun table0_initializer_14 () Bool (= (table0 #x0e) s0))+[GOOD] (define-fun table0_initializer_15 () Bool (= (table0 #x0f) s0))+[GOOD] (define-fun table0_initializer_16 () Bool (= (table0 #x10) s0))+[GOOD] (define-fun table0_initializer_17 () Bool (= (table0 #x11) s0))+[GOOD] (define-fun table0_initializer_18 () Bool (= (table0 #x12) s0))+[GOOD] (define-fun table0_initializer_19 () Bool (= (table0 #x13) s0))+[GOOD] (define-fun table0_initializer_20 () Bool (= (table0 #x14) s0))+[GOOD] (define-fun table0_initializer_21 () Bool (= (table0 #x15) s0))+[GOOD] (define-fun table0_initializer_22 () Bool (= (table0 #x16) s0))+[GOOD] (define-fun table0_initializer_23 () Bool (= (table0 #x17) s0))+[GOOD] (define-fun table0_initializer_24 () Bool (= (table0 #x18) s0))+[GOOD] (define-fun table0_initializer_25 () Bool (= (table0 #x19) s0))+[GOOD] (define-fun table0_initializer_26 () Bool (= (table0 #x1a) s0))+[GOOD] (define-fun table0_initializer_27 () Bool (= (table0 #x1b) s0))+[GOOD] (define-fun table0_initializer_28 () Bool (= (table0 #x1c) s0))+[GOOD] (define-fun table0_initializer_29 () Bool (= (table0 #x1d) s0))+[GOOD] (define-fun table0_initializer_30 () Bool (= (table0 #x1e) s0))+[GOOD] (define-fun table0_initializer_31 () Bool (= (table0 #x1f) s0))+[GOOD] (define-fun table0_initializer_32 () Bool (= (table0 #x20) s0))+[GOOD] (define-fun table0_initializer_33 () Bool (= (table0 #x21) s0))+[GOOD] (define-fun table0_initializer_34 () Bool (= (table0 #x22) s0))+[GOOD] (define-fun table0_initializer_35 () Bool (= (table0 #x23) s0))+[GOOD] (define-fun table0_initializer_36 () Bool (= (table0 #x24) s0))+[GOOD] (define-fun table0_initializer_37 () Bool (= (table0 #x25) s0))+[GOOD] (define-fun table0_initializer_38 () Bool (= (table0 #x26) s0))+[GOOD] (define-fun table0_initializer_39 () Bool (= (table0 #x27) s0))+[GOOD] (define-fun table0_initializer_40 () Bool (= (table0 #x28) s0))+[GOOD] (define-fun table0_initializer_41 () Bool (= (table0 #x29) s0))+[GOOD] (define-fun table0_initializer_42 () Bool (= (table0 #x2a) s0))+[GOOD] (define-fun table0_initializer_43 () Bool (= (table0 #x2b) s0))+[GOOD] (define-fun table0_initializer_44 () Bool (= (table0 #x2c) s0))+[GOOD] (define-fun table0_initializer_45 () Bool (= (table0 #x2d) s0))+[GOOD] (define-fun table0_initializer_46 () Bool (= (table0 #x2e) s0))+[GOOD] (define-fun table0_initializer_47 () Bool (= (table0 #x2f) s0))+[GOOD] (define-fun table0_initializer_48 () Bool (= (table0 #x30) s0))+[GOOD] (define-fun table0_initializer_49 () Bool (= (table0 #x31) s0))+[GOOD] (define-fun table0_initializer_50 () Bool (= (table0 #x32) s0))+[GOOD] (define-fun table0_initializer_51 () Bool (= (table0 #x33) s0))+[GOOD] (define-fun table0_initializer_52 () Bool (= (table0 #x34) s0))+[GOOD] (define-fun table0_initializer_53 () Bool (= (table0 #x35) s0))+[GOOD] (define-fun table0_initializer_54 () Bool (= (table0 #x36) s0))+[GOOD] (define-fun table0_initializer_55 () Bool (= (table0 #x37) s0))+[GOOD] (define-fun table0_initializer_56 () Bool (= (table0 #x38) s0))+[GOOD] (define-fun table0_initializer_57 () Bool (= (table0 #x39) s0))+[GOOD] (define-fun table0_initializer_58 () Bool (= (table0 #x3a) s0))+[GOOD] (define-fun table0_initializer_59 () Bool (= (table0 #x3b) s0))+[GOOD] (define-fun table0_initializer_60 () Bool (= (table0 #x3c) s0))+[GOOD] (define-fun table0_initializer_61 () Bool (= (table0 #x3d) s0))+[GOOD] (define-fun table0_initializer_62 () Bool (= (table0 #x3e) s0))+[GOOD] (define-fun table0_initializer_63 () Bool (= (table0 #x3f) s0))+[GOOD] (define-fun table0_initializer_64 () Bool (= (table0 #x40) s0))+[GOOD] (define-fun table0_initializer_65 () Bool (= (table0 #x41) s0))+[GOOD] (define-fun table0_initializer_66 () Bool (= (table0 #x42) s0))+[GOOD] (define-fun table0_initializer_67 () Bool (= (table0 #x43) s0))+[GOOD] (define-fun table0_initializer_68 () Bool (= (table0 #x44) s0))+[GOOD] (define-fun table0_initializer_69 () Bool (= (table0 #x45) s0))+[GOOD] (define-fun table0_initializer_70 () Bool (= (table0 #x46) s0))+[GOOD] (define-fun table0_initializer_71 () Bool (= (table0 #x47) s0))+[GOOD] (define-fun table0_initializer_72 () Bool (= (table0 #x48) s0))+[GOOD] (define-fun table0_initializer_73 () Bool (= (table0 #x49) s0))+[GOOD] (define-fun table0_initializer_74 () Bool (= (table0 #x4a) s0))+[GOOD] (define-fun table0_initializer_75 () Bool (= (table0 #x4b) s0))+[GOOD] (define-fun table0_initializer_76 () Bool (= (table0 #x4c) s0))+[GOOD] (define-fun table0_initializer_77 () Bool (= (table0 #x4d) s0))+[GOOD] (define-fun table0_initializer_78 () Bool (= (table0 #x4e) s0))+[GOOD] (define-fun table0_initializer_79 () Bool (= (table0 #x4f) s0))+[GOOD] (define-fun table0_initializer_80 () Bool (= (table0 #x50) s0))+[GOOD] (define-fun table0_initializer_81 () Bool (= (table0 #x51) s0))+[GOOD] (define-fun table0_initializer_82 () Bool (= (table0 #x52) s0))+[GOOD] (define-fun table0_initializer_83 () Bool (= (table0 #x53) s0))+[GOOD] (define-fun table0_initializer_84 () Bool (= (table0 #x54) s0))+[GOOD] (define-fun table0_initializer_85 () Bool (= (table0 #x55) s0))+[GOOD] (define-fun table0_initializer_86 () Bool (= (table0 #x56) s0))+[GOOD] (define-fun table0_initializer_87 () Bool (= (table0 #x57) s0))+[GOOD] (define-fun table0_initializer_88 () Bool (= (table0 #x58) s0))+[GOOD] (define-fun table0_initializer_89 () Bool (= (table0 #x59) s0))+[GOOD] (define-fun table0_initializer_90 () Bool (= (table0 #x5a) s0))+[GOOD] (define-fun table0_initializer_91 () Bool (= (table0 #x5b) s0))+[GOOD] (define-fun table0_initializer_92 () Bool (= (table0 #x5c) s0))+[GOOD] (define-fun table0_initializer_93 () Bool (= (table0 #x5d) s0))+[GOOD] (define-fun table0_initializer_94 () Bool (= (table0 #x5e) s0))+[GOOD] (define-fun table0_initializer_95 () Bool (= (table0 #x5f) s0))+[GOOD] (define-fun table0_initializer_96 () Bool (= (table0 #x60) s0))+[GOOD] (define-fun table0_initializer_97 () Bool (= (table0 #x61) s0))+[GOOD] (define-fun table0_initializer_98 () Bool (= (table0 #x62) s0))+[GOOD] (define-fun table0_initializer_99 () Bool (= (table0 #x63) s0))+[GOOD] (define-fun table0_initializer_100 () Bool (= (table0 #x64) s0))+[GOOD] (define-fun table0_initializer_101 () Bool (= (table0 #x65) s0))+[GOOD] (define-fun table0_initializer_102 () Bool (= (table0 #x66) s0))+[GOOD] (define-fun table0_initializer_103 () Bool (= (table0 #x67) s0))+[GOOD] (define-fun table0_initializer_104 () Bool (= (table0 #x68) s0))+[GOOD] (define-fun table0_initializer_105 () Bool (= (table0 #x69) s0))+[GOOD] (define-fun table0_initializer_106 () Bool (= (table0 #x6a) s0))+[GOOD] (define-fun table0_initializer_107 () Bool (= (table0 #x6b) s0))+[GOOD] (define-fun table0_initializer_108 () Bool (= (table0 #x6c) s0))+[GOOD] (define-fun table0_initializer_109 () Bool (= (table0 #x6d) s0))+[GOOD] (define-fun table0_initializer_110 () Bool (= (table0 #x6e) s0))+[GOOD] (define-fun table0_initializer_111 () Bool (= (table0 #x6f) s0))+[GOOD] (define-fun table0_initializer_112 () Bool (= (table0 #x70) s0))+[GOOD] (define-fun table0_initializer_113 () Bool (= (table0 #x71) s0))+[GOOD] (define-fun table0_initializer_114 () Bool (= (table0 #x72) s0))+[GOOD] (define-fun table0_initializer_115 () Bool (= (table0 #x73) s0))+[GOOD] (define-fun table0_initializer_116 () Bool (= (table0 #x74) s0))+[GOOD] (define-fun table0_initializer_117 () Bool (= (table0 #x75) s0))+[GOOD] (define-fun table0_initializer_118 () Bool (= (table0 #x76) s0))+[GOOD] (define-fun table0_initializer_119 () Bool (= (table0 #x77) s0))+[GOOD] (define-fun table0_initializer_120 () Bool (= (table0 #x78) s0))+[GOOD] (define-fun table0_initializer_121 () Bool (= (table0 #x79) s0))+[GOOD] (define-fun table0_initializer_122 () Bool (= (table0 #x7a) s0))+[GOOD] (define-fun table0_initializer_123 () Bool (= (table0 #x7b) s0))+[GOOD] (define-fun table0_initializer_124 () Bool (= (table0 #x7c) s0))+[GOOD] (define-fun table0_initializer_125 () Bool (= (table0 #x7d) s0))+[GOOD] (define-fun table0_initializer_126 () Bool (= (table0 #x7e) s0))+[GOOD] (define-fun table0_initializer_127 () Bool (= (table0 #x7f) s0))+[GOOD] (define-fun table0_initializer_128 () Bool (= (table0 #x80) s0))+[GOOD] (define-fun table0_initializer_129 () Bool (= (table0 #x81) s0))+[GOOD] (define-fun table0_initializer_130 () Bool (= (table0 #x82) s0))+[GOOD] (define-fun table0_initializer_131 () Bool (= (table0 #x83) s0))+[GOOD] (define-fun table0_initializer_132 () Bool (= (table0 #x84) s0))+[GOOD] (define-fun table0_initializer_133 () Bool (= (table0 #x85) s0))+[GOOD] (define-fun table0_initializer_134 () Bool (= (table0 #x86) s0))+[GOOD] (define-fun table0_initializer_135 () Bool (= (table0 #x87) s0))+[GOOD] (define-fun table0_initializer_136 () Bool (= (table0 #x88) s0))+[GOOD] (define-fun table0_initializer_137 () Bool (= (table0 #x89) s0))+[GOOD] (define-fun table0_initializer_138 () Bool (= (table0 #x8a) s0))+[GOOD] (define-fun table0_initializer_139 () Bool (= (table0 #x8b) s0))+[GOOD] (define-fun table0_initializer_140 () Bool (= (table0 #x8c) s0))+[GOOD] (define-fun table0_initializer_141 () Bool (= (table0 #x8d) s0))+[GOOD] (define-fun table0_initializer_142 () Bool (= (table0 #x8e) s0))+[GOOD] (define-fun table0_initializer_143 () Bool (= (table0 #x8f) s0))+[GOOD] (define-fun table0_initializer_144 () Bool (= (table0 #x90) s0))+[GOOD] (define-fun table0_initializer_145 () Bool (= (table0 #x91) s0))+[GOOD] (define-fun table0_initializer_146 () Bool (= (table0 #x92) s0))+[GOOD] (define-fun table0_initializer_147 () Bool (= (table0 #x93) s0))+[GOOD] (define-fun table0_initializer_148 () Bool (= (table0 #x94) s0))+[GOOD] (define-fun table0_initializer_149 () Bool (= (table0 #x95) s0))+[GOOD] (define-fun table0_initializer_150 () Bool (= (table0 #x96) s0))+[GOOD] (define-fun table0_initializer_151 () Bool (= (table0 #x97) s0))+[GOOD] (define-fun table0_initializer_152 () Bool (= (table0 #x98) s0))+[GOOD] (define-fun table0_initializer_153 () Bool (= (table0 #x99) s0))+[GOOD] (define-fun table0_initializer_154 () Bool (= (table0 #x9a) s0))+[GOOD] (define-fun table0_initializer_155 () Bool (= (table0 #x9b) s0))+[GOOD] (define-fun table0_initializer_156 () Bool (= (table0 #x9c) s0))+[GOOD] (define-fun table0_initializer_157 () Bool (= (table0 #x9d) s0))+[GOOD] (define-fun table0_initializer_158 () Bool (= (table0 #x9e) s0))+[GOOD] (define-fun table0_initializer_159 () Bool (= (table0 #x9f) s0))+[GOOD] (define-fun table0_initializer_160 () Bool (= (table0 #xa0) s0))+[GOOD] (define-fun table0_initializer_161 () Bool (= (table0 #xa1) s0))+[GOOD] (define-fun table0_initializer_162 () Bool (= (table0 #xa2) s0))+[GOOD] (define-fun table0_initializer_163 () Bool (= (table0 #xa3) s0))+[GOOD] (define-fun table0_initializer_164 () Bool (= (table0 #xa4) s0))+[GOOD] (define-fun table0_initializer_165 () Bool (= (table0 #xa5) s0))+[GOOD] (define-fun table0_initializer_166 () Bool (= (table0 #xa6) s0))+[GOOD] (define-fun table0_initializer_167 () Bool (= (table0 #xa7) s0))+[GOOD] (define-fun table0_initializer_168 () Bool (= (table0 #xa8) s0))+[GOOD] (define-fun table0_initializer_169 () Bool (= (table0 #xa9) s0))+[GOOD] (define-fun table0_initializer_170 () Bool (= (table0 #xaa) s0))+[GOOD] (define-fun table0_initializer_171 () Bool (= (table0 #xab) s0))+[GOOD] (define-fun table0_initializer_172 () Bool (= (table0 #xac) s0))+[GOOD] (define-fun table0_initializer_173 () Bool (= (table0 #xad) s0))+[GOOD] (define-fun table0_initializer_174 () Bool (= (table0 #xae) s0))+[GOOD] (define-fun table0_initializer_175 () Bool (= (table0 #xaf) s0))+[GOOD] (define-fun table0_initializer_176 () Bool (= (table0 #xb0) s0))+[GOOD] (define-fun table0_initializer_177 () Bool (= (table0 #xb1) s0))+[GOOD] (define-fun table0_initializer_178 () Bool (= (table0 #xb2) s0))+[GOOD] (define-fun table0_initializer_179 () Bool (= (table0 #xb3) s0))+[GOOD] (define-fun table0_initializer_180 () Bool (= (table0 #xb4) s0))+[GOOD] (define-fun table0_initializer_181 () Bool (= (table0 #xb5) s0))+[GOOD] (define-fun table0_initializer_182 () Bool (= (table0 #xb6) s0))+[GOOD] (define-fun table0_initializer_183 () Bool (= (table0 #xb7) s0))+[GOOD] (define-fun table0_initializer_184 () Bool (= (table0 #xb8) s0))+[GOOD] (define-fun table0_initializer_185 () Bool (= (table0 #xb9) s0))+[GOOD] (define-fun table0_initializer_186 () Bool (= (table0 #xba) s0))+[GOOD] (define-fun table0_initializer_187 () Bool (= (table0 #xbb) s0))+[GOOD] (define-fun table0_initializer_188 () Bool (= (table0 #xbc) s0))+[GOOD] (define-fun table0_initializer_189 () Bool (= (table0 #xbd) s0))+[GOOD] (define-fun table0_initializer_190 () Bool (= (table0 #xbe) s0))+[GOOD] (define-fun table0_initializer_191 () Bool (= (table0 #xbf) s0))+[GOOD] (define-fun table0_initializer_192 () Bool (= (table0 #xc0) s0))+[GOOD] (define-fun table0_initializer_193 () Bool (= (table0 #xc1) s0))+[GOOD] (define-fun table0_initializer_194 () Bool (= (table0 #xc2) s0))+[GOOD] (define-fun table0_initializer_195 () Bool (= (table0 #xc3) s0))+[GOOD] (define-fun table0_initializer_196 () Bool (= (table0 #xc4) s0))+[GOOD] (define-fun table0_initializer_197 () Bool (= (table0 #xc5) s0))+[GOOD] (define-fun table0_initializer_198 () Bool (= (table0 #xc6) s0))+[GOOD] (define-fun table0_initializer_199 () Bool (= (table0 #xc7) s0))+[GOOD] (define-fun table0_initializer_200 () Bool (= (table0 #xc8) s0))+[GOOD] (define-fun table0_initializer_201 () Bool (= (table0 #xc9) s0))+[GOOD] (define-fun table0_initializer_202 () Bool (= (table0 #xca) s0))+[GOOD] (define-fun table0_initializer_203 () Bool (= (table0 #xcb) s0))+[GOOD] (define-fun table0_initializer_204 () Bool (= (table0 #xcc) s0))+[GOOD] (define-fun table0_initializer_205 () Bool (= (table0 #xcd) s0))+[GOOD] (define-fun table0_initializer_206 () Bool (= (table0 #xce) s0))+[GOOD] (define-fun table0_initializer_207 () Bool (= (table0 #xcf) s0))+[GOOD] (define-fun table0_initializer_208 () Bool (= (table0 #xd0) s0))+[GOOD] (define-fun table0_initializer_209 () Bool (= (table0 #xd1) s0))+[GOOD] (define-fun table0_initializer_210 () Bool (= (table0 #xd2) s0))+[GOOD] (define-fun table0_initializer_211 () Bool (= (table0 #xd3) s0))+[GOOD] (define-fun table0_initializer_212 () Bool (= (table0 #xd4) s0))+[GOOD] (define-fun table0_initializer_213 () Bool (= (table0 #xd5) s0))+[GOOD] (define-fun table0_initializer_214 () Bool (= (table0 #xd6) s0))+[GOOD] (define-fun table0_initializer_215 () Bool (= (table0 #xd7) s0))+[GOOD] (define-fun table0_initializer_216 () Bool (= (table0 #xd8) s0))+[GOOD] (define-fun table0_initializer_217 () Bool (= (table0 #xd9) s0))+[GOOD] (define-fun table0_initializer_218 () Bool (= (table0 #xda) s0))+[GOOD] (define-fun table0_initializer_219 () Bool (= (table0 #xdb) s0))+[GOOD] (define-fun table0_initializer_220 () Bool (= (table0 #xdc) s0))+[GOOD] (define-fun table0_initializer_221 () Bool (= (table0 #xdd) s0))+[GOOD] (define-fun table0_initializer_222 () Bool (= (table0 #xde) s0))+[GOOD] (define-fun table0_initializer_223 () Bool (= (table0 #xdf) s0))+[GOOD] (define-fun table0_initializer_224 () Bool (= (table0 #xe0) s0))+[GOOD] (define-fun table0_initializer_225 () Bool (= (table0 #xe1) s0))+[GOOD] (define-fun table0_initializer_226 () Bool (= (table0 #xe2) s0))+[GOOD] (define-fun table0_initializer_227 () Bool (= (table0 #xe3) s0))+[GOOD] (define-fun table0_initializer_228 () Bool (= (table0 #xe4) s0))+[GOOD] (define-fun table0_initializer_229 () Bool (= (table0 #xe5) s0))+[GOOD] (define-fun table0_initializer_230 () Bool (= (table0 #xe6) s0))+[GOOD] (define-fun table0_initializer_231 () Bool (= (table0 #xe7) s0))+[GOOD] (define-fun table0_initializer_232 () Bool (= (table0 #xe8) s0))+[GOOD] (define-fun table0_initializer_233 () Bool (= (table0 #xe9) s0))+[GOOD] (define-fun table0_initializer_234 () Bool (= (table0 #xea) s0))+[GOOD] (define-fun table0_initializer_235 () Bool (= (table0 #xeb) s0))+[GOOD] (define-fun table0_initializer_236 () Bool (= (table0 #xec) s0))+[GOOD] (define-fun table0_initializer_237 () Bool (= (table0 #xed) s0))+[GOOD] (define-fun table0_initializer_238 () Bool (= (table0 #xee) s0))+[GOOD] (define-fun table0_initializer_239 () Bool (= (table0 #xef) s0))+[GOOD] (define-fun table0_initializer_240 () Bool (= (table0 #xf0) s0))+[GOOD] (define-fun table0_initializer_241 () Bool (= (table0 #xf1) s0))+[GOOD] (define-fun table0_initializer_242 () Bool (= (table0 #xf2) s0))+[GOOD] (define-fun table0_initializer_243 () Bool (= (table0 #xf3) s0))+[GOOD] (define-fun table0_initializer_244 () Bool (= (table0 #xf4) s0))+[GOOD] (define-fun table0_initializer_245 () Bool (= (table0 #xf5) s0))+[GOOD] (define-fun table0_initializer_246 () Bool (= (table0 #xf6) s0))+[GOOD] (define-fun table0_initializer_247 () Bool (= (table0 #xf7) s0))+[GOOD] (define-fun table0_initializer_248 () Bool (= (table0 #xf8) s0))+[GOOD] (define-fun table0_initializer_249 () Bool (= (table0 #xf9) s0))+[GOOD] (define-fun table0_initializer_250 () Bool (= (table0 #xfa) s0))+[GOOD] (define-fun table0_initializer_251 () Bool (= (table0 #xfb) s0))+[GOOD] (define-fun table0_initializer_252 () Bool (= (table0 #xfc) s0))+[GOOD] (define-fun table0_initializer_253 () Bool (= (table0 #xfd) s0))+[GOOD] (define-fun table0_initializer_254 () Bool (= (table0 #xfe) s0))+[GOOD] (define-fun table0_initializer_255 () Bool (= (table0 #xff) s0))+[GOOD] (define-fun table0_initializer () Bool (and table0_initializer_0 table0_initializer_1 table0_initializer_2 table0_initializer_3 table0_initializer_4 table0_initializer_5 table0_initializer_6 table0_initializer_7 table0_initializer_8 table0_initializer_9 table0_initializer_10 table0_initializer_11 table0_initializer_12 table0_initializer_13 table0_initializer_14 table0_initializer_15 table0_initializer_16 table0_initializer_17 table0_initializer_18 table0_initializer_19 table0_initializer_20 table0_initializer_21 table0_initializer_22 table0_initializer_23 table0_initializer_24 table0_initializer_25 table0_initializer_26 table0_initializer_27 table0_initializer_28 table0_initializer_29 table0_initializer_30 table0_initializer_31 table0_initializer_32 table0_initializer_33 table0_initializer_34 table0_initializer_35 table0_initializer_36 table0_initializer_37 table0_initializer_38 table0_initializer_39 table0_initializer_40 table0_initializer_41 table0_initializer_42 table0_initializer_43 table0_initializer_44 table0_initializer_45 table0_initializer_46 table0_initializer_47 table0_initializer_48 table0_initializer_49 table0_initializer_50 table0_initializer_51 table0_initializer_52 table0_initializer_53 table0_initializer_54 table0_initializer_55 table0_initializer_56 table0_initializer_57 table0_initializer_58 table0_initializer_59 table0_initializer_60 table0_initializer_61 table0_initializer_62 table0_initializer_63 table0_initializer_64 table0_initializer_65 table0_initializer_66 table0_initializer_67 table0_initializer_68 table0_initializer_69 table0_initializer_70 table0_initializer_71 table0_initializer_72 table0_initializer_73 table0_initializer_74 table0_initializer_75 table0_initializer_76 table0_initializer_77 table0_initializer_78 table0_initializer_79 table0_initializer_80 table0_initializer_81 table0_initializer_82 table0_initializer_83 table0_initializer_84 table0_initializer_85 table0_initializer_86 table0_initializer_87 table0_initializer_88 table0_initializer_89 table0_initializer_90 table0_initializer_91 table0_initializer_92 table0_initializer_93 table0_initializer_94 table0_initializer_95 table0_initializer_96 table0_initializer_97 table0_initializer_98 table0_initializer_99 table0_initializer_100 table0_initializer_101 table0_initializer_102 table0_initializer_103 table0_initializer_104 table0_initializer_105 table0_initializer_106 table0_initializer_107 table0_initializer_108 table0_initializer_109 table0_initializer_110 table0_initializer_111 table0_initializer_112 table0_initializer_113 table0_initializer_114 table0_initializer_115 table0_initializer_116 table0_initializer_117 table0_initializer_118 table0_initializer_119 table0_initializer_120 table0_initializer_121 table0_initializer_122 table0_initializer_123 table0_initializer_124 table0_initializer_125 table0_initializer_126 table0_initializer_127 table0_initializer_128 table0_initializer_129 table0_initializer_130 table0_initializer_131 table0_initializer_132 table0_initializer_133 table0_initializer_134 table0_initializer_135 table0_initializer_136 table0_initializer_137 table0_initializer_138 table0_initializer_139 table0_initializer_140 table0_initializer_141 table0_initializer_142 table0_initializer_143 table0_initializer_144 table0_initializer_145 table0_initializer_146 table0_initializer_147 table0_initializer_148 table0_initializer_149 table0_initializer_150 table0_initializer_151 table0_initializer_152 table0_initializer_153 table0_initializer_154 table0_initializer_155 table0_initializer_156 table0_initializer_157 table0_initializer_158 table0_initializer_159 table0_initializer_160 table0_initializer_161 table0_initializer_162 table0_initializer_163 table0_initializer_164 table0_initializer_165 table0_initializer_166 table0_initializer_167 table0_initializer_168 table0_initializer_169 table0_initializer_170 table0_initializer_171 table0_initializer_172 table0_initializer_173 table0_initializer_174 table0_initializer_175 table0_initializer_176 table0_initializer_177 table0_initializer_178 table0_initializer_179 table0_initializer_180 table0_initializer_181 table0_initializer_182 table0_initializer_183 table0_initializer_184 table0_initializer_185 table0_initializer_186 table0_initializer_187 table0_initializer_188 table0_initializer_189 table0_initializer_190 table0_initializer_191 table0_initializer_192 table0_initializer_193 table0_initializer_194 table0_initializer_195 table0_initializer_196 table0_initializer_197 table0_initializer_198 table0_initializer_199 table0_initializer_200 table0_initializer_201 table0_initializer_202 table0_initializer_203 table0_initializer_204 table0_initializer_205 table0_initializer_206 table0_initializer_207 table0_initializer_208 table0_initializer_209 table0_initializer_210 table0_initializer_211 table0_initializer_212 table0_initializer_213 table0_initializer_214 table0_initializer_215 table0_initializer_216 table0_initializer_217 table0_initializer_218 table0_initializer_219 table0_initializer_220 table0_initializer_221 table0_initializer_222 table0_initializer_223 table0_initializer_224 table0_initializer_225 table0_initializer_226 table0_initializer_227 table0_initializer_228 table0_initializer_229 table0_initializer_230 table0_initializer_231 table0_initializer_232 table0_initializer_233 table0_initializer_234 table0_initializer_235 table0_initializer_236 table0_initializer_237 table0_initializer_238 table0_initializer_239 table0_initializer_240 table0_initializer_241 table0_initializer_242 table0_initializer_243 table0_initializer_244 table0_initializer_245 table0_initializer_246 table0_initializer_247 table0_initializer_248 table0_initializer_249 table0_initializer_250 table0_initializer_251 table0_initializer_252 table0_initializer_253 table0_initializer_254 table0_initializer_255))+[GOOD] (assert table0_initializer) [GOOD] (define-fun s2 () (_ BitVec 8) (table0 s0)) [GOOD] (define-fun s3 () Bool (= s0 s2)) [GOOD] (assert s3)
SBVTestSuite/GoldFiles/queryArrays4.gold view
@@ -276,262 +276,264 @@ [GOOD] (define-fun s256 () (_ BitVec 8) #xfe) [GOOD] (define-fun s257 () (_ BitVec 8) #xff) [GOOD] (declare-fun table0 ((_ BitVec 8)) (_ BitVec 8))-[GOOD] (assert (= (table0 #x00) s2))-[GOOD] (assert (= (table0 #x01) s3))-[GOOD] (assert (= (table0 #x02) s4))-[GOOD] (assert (= (table0 #x03) s5))-[GOOD] (assert (= (table0 #x04) s6))-[GOOD] (assert (= (table0 #x05) s7))-[GOOD] (assert (= (table0 #x06) s8))-[GOOD] (assert (= (table0 #x07) s9))-[GOOD] (assert (= (table0 #x08) s10))-[GOOD] (assert (= (table0 #x09) s11))-[GOOD] (assert (= (table0 #x0a) s12))-[GOOD] (assert (= (table0 #x0b) s13))-[GOOD] (assert (= (table0 #x0c) s14))-[GOOD] (assert (= (table0 #x0d) s15))-[GOOD] (assert (= (table0 #x0e) s16))-[GOOD] (assert (= (table0 #x0f) s17))-[GOOD] (assert (= (table0 #x10) s18))-[GOOD] (assert (= (table0 #x11) s19))-[GOOD] (assert (= (table0 #x12) s20))-[GOOD] (assert (= (table0 #x13) s21))-[GOOD] (assert (= (table0 #x14) s22))-[GOOD] (assert (= (table0 #x15) s23))-[GOOD] (assert (= (table0 #x16) s24))-[GOOD] (assert (= (table0 #x17) s25))-[GOOD] (assert (= (table0 #x18) s26))-[GOOD] (assert (= (table0 #x19) s27))-[GOOD] (assert (= (table0 #x1a) s28))-[GOOD] (assert (= (table0 #x1b) s29))-[GOOD] (assert (= (table0 #x1c) s30))-[GOOD] (assert (= (table0 #x1d) s31))-[GOOD] (assert (= (table0 #x1e) s32))-[GOOD] (assert (= (table0 #x1f) s33))-[GOOD] (assert (= (table0 #x20) s34))-[GOOD] (assert (= (table0 #x21) s35))-[GOOD] (assert (= (table0 #x22) s36))-[GOOD] (assert (= (table0 #x23) s37))-[GOOD] (assert (= (table0 #x24) s38))-[GOOD] (assert (= (table0 #x25) s39))-[GOOD] (assert (= (table0 #x26) s40))-[GOOD] (assert (= (table0 #x27) s41))-[GOOD] (assert (= (table0 #x28) s42))-[GOOD] (assert (= (table0 #x29) s43))-[GOOD] (assert (= (table0 #x2a) s44))-[GOOD] (assert (= (table0 #x2b) s45))-[GOOD] (assert (= (table0 #x2c) s46))-[GOOD] (assert (= (table0 #x2d) s47))-[GOOD] (assert (= (table0 #x2e) s48))-[GOOD] (assert (= (table0 #x2f) s49))-[GOOD] (assert (= (table0 #x30) s50))-[GOOD] (assert (= (table0 #x31) s51))-[GOOD] (assert (= (table0 #x32) s52))-[GOOD] (assert (= (table0 #x33) s53))-[GOOD] (assert (= (table0 #x34) s54))-[GOOD] (assert (= (table0 #x35) s55))-[GOOD] (assert (= (table0 #x36) s56))-[GOOD] (assert (= (table0 #x37) s57))-[GOOD] (assert (= (table0 #x38) s58))-[GOOD] (assert (= (table0 #x39) s59))-[GOOD] (assert (= (table0 #x3a) s60))-[GOOD] (assert (= (table0 #x3b) s61))-[GOOD] (assert (= (table0 #x3c) s62))-[GOOD] (assert (= (table0 #x3d) s63))-[GOOD] (assert (= (table0 #x3e) s64))-[GOOD] (assert (= (table0 #x3f) s65))-[GOOD] (assert (= (table0 #x40) s66))-[GOOD] (assert (= (table0 #x41) s67))-[GOOD] (assert (= (table0 #x42) s68))-[GOOD] (assert (= (table0 #x43) s69))-[GOOD] (assert (= (table0 #x44) s70))-[GOOD] (assert (= (table0 #x45) s71))-[GOOD] (assert (= (table0 #x46) s72))-[GOOD] (assert (= (table0 #x47) s73))-[GOOD] (assert (= (table0 #x48) s74))-[GOOD] (assert (= (table0 #x49) s75))-[GOOD] (assert (= (table0 #x4a) s76))-[GOOD] (assert (= (table0 #x4b) s77))-[GOOD] (assert (= (table0 #x4c) s78))-[GOOD] (assert (= (table0 #x4d) s79))-[GOOD] (assert (= (table0 #x4e) s80))-[GOOD] (assert (= (table0 #x4f) s81))-[GOOD] (assert (= (table0 #x50) s82))-[GOOD] (assert (= (table0 #x51) s83))-[GOOD] (assert (= (table0 #x52) s84))-[GOOD] (assert (= (table0 #x53) s85))-[GOOD] (assert (= (table0 #x54) s86))-[GOOD] (assert (= (table0 #x55) s87))-[GOOD] (assert (= (table0 #x56) s88))-[GOOD] (assert (= (table0 #x57) s89))-[GOOD] (assert (= (table0 #x58) s90))-[GOOD] (assert (= (table0 #x59) s91))-[GOOD] (assert (= (table0 #x5a) s92))-[GOOD] (assert (= (table0 #x5b) s93))-[GOOD] (assert (= (table0 #x5c) s94))-[GOOD] (assert (= (table0 #x5d) s95))-[GOOD] (assert (= (table0 #x5e) s96))-[GOOD] (assert (= (table0 #x5f) s97))-[GOOD] (assert (= (table0 #x60) s98))-[GOOD] (assert (= (table0 #x61) s99))-[GOOD] (assert (= (table0 #x62) s100))-[GOOD] (assert (= (table0 #x63) s101))-[GOOD] (assert (= (table0 #x64) s102))-[GOOD] (assert (= (table0 #x65) s103))-[GOOD] (assert (= (table0 #x66) s104))-[GOOD] (assert (= (table0 #x67) s105))-[GOOD] (assert (= (table0 #x68) s106))-[GOOD] (assert (= (table0 #x69) s107))-[GOOD] (assert (= (table0 #x6a) s108))-[GOOD] (assert (= (table0 #x6b) s109))-[GOOD] (assert (= (table0 #x6c) s110))-[GOOD] (assert (= (table0 #x6d) s111))-[GOOD] (assert (= (table0 #x6e) s112))-[GOOD] (assert (= (table0 #x6f) s113))-[GOOD] (assert (= (table0 #x70) s114))-[GOOD] (assert (= (table0 #x71) s115))-[GOOD] (assert (= (table0 #x72) s116))-[GOOD] (assert (= (table0 #x73) s117))-[GOOD] (assert (= (table0 #x74) s118))-[GOOD] (assert (= (table0 #x75) s119))-[GOOD] (assert (= (table0 #x76) s120))-[GOOD] (assert (= (table0 #x77) s121))-[GOOD] (assert (= (table0 #x78) s122))-[GOOD] (assert (= (table0 #x79) s123))-[GOOD] (assert (= (table0 #x7a) s124))-[GOOD] (assert (= (table0 #x7b) s125))-[GOOD] (assert (= (table0 #x7c) s126))-[GOOD] (assert (= (table0 #x7d) s127))-[GOOD] (assert (= (table0 #x7e) s128))-[GOOD] (assert (= (table0 #x7f) s129))-[GOOD] (assert (= (table0 #x80) s130))-[GOOD] (assert (= (table0 #x81) s131))-[GOOD] (assert (= (table0 #x82) s132))-[GOOD] (assert (= (table0 #x83) s133))-[GOOD] (assert (= (table0 #x84) s134))-[GOOD] (assert (= (table0 #x85) s135))-[GOOD] (assert (= (table0 #x86) s136))-[GOOD] (assert (= (table0 #x87) s137))-[GOOD] (assert (= (table0 #x88) s138))-[GOOD] (assert (= (table0 #x89) s139))-[GOOD] (assert (= (table0 #x8a) s140))-[GOOD] (assert (= (table0 #x8b) s141))-[GOOD] (assert (= (table0 #x8c) s142))-[GOOD] (assert (= (table0 #x8d) s143))-[GOOD] (assert (= (table0 #x8e) s144))-[GOOD] (assert (= (table0 #x8f) s145))-[GOOD] (assert (= (table0 #x90) s146))-[GOOD] (assert (= (table0 #x91) s147))-[GOOD] (assert (= (table0 #x92) s148))-[GOOD] (assert (= (table0 #x93) s149))-[GOOD] (assert (= (table0 #x94) s150))-[GOOD] (assert (= (table0 #x95) s151))-[GOOD] (assert (= (table0 #x96) s152))-[GOOD] (assert (= (table0 #x97) s153))-[GOOD] (assert (= (table0 #x98) s154))-[GOOD] (assert (= (table0 #x99) s155))-[GOOD] (assert (= (table0 #x9a) s156))-[GOOD] (assert (= (table0 #x9b) s157))-[GOOD] (assert (= (table0 #x9c) s158))-[GOOD] (assert (= (table0 #x9d) s159))-[GOOD] (assert (= (table0 #x9e) s160))-[GOOD] (assert (= (table0 #x9f) s161))-[GOOD] (assert (= (table0 #xa0) s162))-[GOOD] (assert (= (table0 #xa1) s163))-[GOOD] (assert (= (table0 #xa2) s164))-[GOOD] (assert (= (table0 #xa3) s165))-[GOOD] (assert (= (table0 #xa4) s166))-[GOOD] (assert (= (table0 #xa5) s167))-[GOOD] (assert (= (table0 #xa6) s168))-[GOOD] (assert (= (table0 #xa7) s169))-[GOOD] (assert (= (table0 #xa8) s170))-[GOOD] (assert (= (table0 #xa9) s171))-[GOOD] (assert (= (table0 #xaa) s172))-[GOOD] (assert (= (table0 #xab) s173))-[GOOD] (assert (= (table0 #xac) s174))-[GOOD] (assert (= (table0 #xad) s175))-[GOOD] (assert (= (table0 #xae) s176))-[GOOD] (assert (= (table0 #xaf) s177))-[GOOD] (assert (= (table0 #xb0) s178))-[GOOD] (assert (= (table0 #xb1) s179))-[GOOD] (assert (= (table0 #xb2) s180))-[GOOD] (assert (= (table0 #xb3) s181))-[GOOD] (assert (= (table0 #xb4) s182))-[GOOD] (assert (= (table0 #xb5) s183))-[GOOD] (assert (= (table0 #xb6) s184))-[GOOD] (assert (= (table0 #xb7) s185))-[GOOD] (assert (= (table0 #xb8) s186))-[GOOD] (assert (= (table0 #xb9) s187))-[GOOD] (assert (= (table0 #xba) s188))-[GOOD] (assert (= (table0 #xbb) s189))-[GOOD] (assert (= (table0 #xbc) s190))-[GOOD] (assert (= (table0 #xbd) s191))-[GOOD] (assert (= (table0 #xbe) s192))-[GOOD] (assert (= (table0 #xbf) s193))-[GOOD] (assert (= (table0 #xc0) s194))-[GOOD] (assert (= (table0 #xc1) s195))-[GOOD] (assert (= (table0 #xc2) s196))-[GOOD] (assert (= (table0 #xc3) s197))-[GOOD] (assert (= (table0 #xc4) s198))-[GOOD] (assert (= (table0 #xc5) s199))-[GOOD] (assert (= (table0 #xc6) s200))-[GOOD] (assert (= (table0 #xc7) s201))-[GOOD] (assert (= (table0 #xc8) s202))-[GOOD] (assert (= (table0 #xc9) s203))-[GOOD] (assert (= (table0 #xca) s204))-[GOOD] (assert (= (table0 #xcb) s205))-[GOOD] (assert (= (table0 #xcc) s206))-[GOOD] (assert (= (table0 #xcd) s207))-[GOOD] (assert (= (table0 #xce) s208))-[GOOD] (assert (= (table0 #xcf) s209))-[GOOD] (assert (= (table0 #xd0) s210))-[GOOD] (assert (= (table0 #xd1) s211))-[GOOD] (assert (= (table0 #xd2) s212))-[GOOD] (assert (= (table0 #xd3) s213))-[GOOD] (assert (= (table0 #xd4) s214))-[GOOD] (assert (= (table0 #xd5) s215))-[GOOD] (assert (= (table0 #xd6) s216))-[GOOD] (assert (= (table0 #xd7) s217))-[GOOD] (assert (= (table0 #xd8) s218))-[GOOD] (assert (= (table0 #xd9) s219))-[GOOD] (assert (= (table0 #xda) s220))-[GOOD] (assert (= (table0 #xdb) s221))-[GOOD] (assert (= (table0 #xdc) s222))-[GOOD] (assert (= (table0 #xdd) s223))-[GOOD] (assert (= (table0 #xde) s224))-[GOOD] (assert (= (table0 #xdf) s225))-[GOOD] (assert (= (table0 #xe0) s226))-[GOOD] (assert (= (table0 #xe1) s227))-[GOOD] (assert (= (table0 #xe2) s228))-[GOOD] (assert (= (table0 #xe3) s229))-[GOOD] (assert (= (table0 #xe4) s230))-[GOOD] (assert (= (table0 #xe5) s231))-[GOOD] (assert (= (table0 #xe6) s232))-[GOOD] (assert (= (table0 #xe7) s233))-[GOOD] (assert (= (table0 #xe8) s234))-[GOOD] (assert (= (table0 #xe9) s235))-[GOOD] (assert (= (table0 #xea) s236))-[GOOD] (assert (= (table0 #xeb) s237))-[GOOD] (assert (= (table0 #xec) s238))-[GOOD] (assert (= (table0 #xed) s239))-[GOOD] (assert (= (table0 #xee) s240))-[GOOD] (assert (= (table0 #xef) s241))-[GOOD] (assert (= (table0 #xf0) s242))-[GOOD] (assert (= (table0 #xf1) s243))-[GOOD] (assert (= (table0 #xf2) s244))-[GOOD] (assert (= (table0 #xf3) s245))-[GOOD] (assert (= (table0 #xf4) s246))-[GOOD] (assert (= (table0 #xf5) s247))-[GOOD] (assert (= (table0 #xf6) s248))-[GOOD] (assert (= (table0 #xf7) s249))-[GOOD] (assert (= (table0 #xf8) s250))-[GOOD] (assert (= (table0 #xf9) s251))-[GOOD] (assert (= (table0 #xfa) s252))-[GOOD] (assert (= (table0 #xfb) s253))-[GOOD] (assert (= (table0 #xfc) s254))-[GOOD] (assert (= (table0 #xfd) s255))-[GOOD] (assert (= (table0 #xfe) s256))-[GOOD] (assert (= (table0 #xff) s257))+[GOOD] (define-fun table0_initializer_0 () Bool (= (table0 #x00) s2))+[GOOD] (define-fun table0_initializer_1 () Bool (= (table0 #x01) s3))+[GOOD] (define-fun table0_initializer_2 () Bool (= (table0 #x02) s4))+[GOOD] (define-fun table0_initializer_3 () Bool (= (table0 #x03) s5))+[GOOD] (define-fun table0_initializer_4 () Bool (= (table0 #x04) s6))+[GOOD] (define-fun table0_initializer_5 () Bool (= (table0 #x05) s7))+[GOOD] (define-fun table0_initializer_6 () Bool (= (table0 #x06) s8))+[GOOD] (define-fun table0_initializer_7 () Bool (= (table0 #x07) s9))+[GOOD] (define-fun table0_initializer_8 () Bool (= (table0 #x08) s10))+[GOOD] (define-fun table0_initializer_9 () Bool (= (table0 #x09) s11))+[GOOD] (define-fun table0_initializer_10 () Bool (= (table0 #x0a) s12))+[GOOD] (define-fun table0_initializer_11 () Bool (= (table0 #x0b) s13))+[GOOD] (define-fun table0_initializer_12 () Bool (= (table0 #x0c) s14))+[GOOD] (define-fun table0_initializer_13 () Bool (= (table0 #x0d) s15))+[GOOD] (define-fun table0_initializer_14 () Bool (= (table0 #x0e) s16))+[GOOD] (define-fun table0_initializer_15 () Bool (= (table0 #x0f) s17))+[GOOD] (define-fun table0_initializer_16 () Bool (= (table0 #x10) s18))+[GOOD] (define-fun table0_initializer_17 () Bool (= (table0 #x11) s19))+[GOOD] (define-fun table0_initializer_18 () Bool (= (table0 #x12) s20))+[GOOD] (define-fun table0_initializer_19 () Bool (= (table0 #x13) s21))+[GOOD] (define-fun table0_initializer_20 () Bool (= (table0 #x14) s22))+[GOOD] (define-fun table0_initializer_21 () Bool (= (table0 #x15) s23))+[GOOD] (define-fun table0_initializer_22 () Bool (= (table0 #x16) s24))+[GOOD] (define-fun table0_initializer_23 () Bool (= (table0 #x17) s25))+[GOOD] (define-fun table0_initializer_24 () Bool (= (table0 #x18) s26))+[GOOD] (define-fun table0_initializer_25 () Bool (= (table0 #x19) s27))+[GOOD] (define-fun table0_initializer_26 () Bool (= (table0 #x1a) s28))+[GOOD] (define-fun table0_initializer_27 () Bool (= (table0 #x1b) s29))+[GOOD] (define-fun table0_initializer_28 () Bool (= (table0 #x1c) s30))+[GOOD] (define-fun table0_initializer_29 () Bool (= (table0 #x1d) s31))+[GOOD] (define-fun table0_initializer_30 () Bool (= (table0 #x1e) s32))+[GOOD] (define-fun table0_initializer_31 () Bool (= (table0 #x1f) s33))+[GOOD] (define-fun table0_initializer_32 () Bool (= (table0 #x20) s34))+[GOOD] (define-fun table0_initializer_33 () Bool (= (table0 #x21) s35))+[GOOD] (define-fun table0_initializer_34 () Bool (= (table0 #x22) s36))+[GOOD] (define-fun table0_initializer_35 () Bool (= (table0 #x23) s37))+[GOOD] (define-fun table0_initializer_36 () Bool (= (table0 #x24) s38))+[GOOD] (define-fun table0_initializer_37 () Bool (= (table0 #x25) s39))+[GOOD] (define-fun table0_initializer_38 () Bool (= (table0 #x26) s40))+[GOOD] (define-fun table0_initializer_39 () Bool (= (table0 #x27) s41))+[GOOD] (define-fun table0_initializer_40 () Bool (= (table0 #x28) s42))+[GOOD] (define-fun table0_initializer_41 () Bool (= (table0 #x29) s43))+[GOOD] (define-fun table0_initializer_42 () Bool (= (table0 #x2a) s44))+[GOOD] (define-fun table0_initializer_43 () Bool (= (table0 #x2b) s45))+[GOOD] (define-fun table0_initializer_44 () Bool (= (table0 #x2c) s46))+[GOOD] (define-fun table0_initializer_45 () Bool (= (table0 #x2d) s47))+[GOOD] (define-fun table0_initializer_46 () Bool (= (table0 #x2e) s48))+[GOOD] (define-fun table0_initializer_47 () Bool (= (table0 #x2f) s49))+[GOOD] (define-fun table0_initializer_48 () Bool (= (table0 #x30) s50))+[GOOD] (define-fun table0_initializer_49 () Bool (= (table0 #x31) s51))+[GOOD] (define-fun table0_initializer_50 () Bool (= (table0 #x32) s52))+[GOOD] (define-fun table0_initializer_51 () Bool (= (table0 #x33) s53))+[GOOD] (define-fun table0_initializer_52 () Bool (= (table0 #x34) s54))+[GOOD] (define-fun table0_initializer_53 () Bool (= (table0 #x35) s55))+[GOOD] (define-fun table0_initializer_54 () Bool (= (table0 #x36) s56))+[GOOD] (define-fun table0_initializer_55 () Bool (= (table0 #x37) s57))+[GOOD] (define-fun table0_initializer_56 () Bool (= (table0 #x38) s58))+[GOOD] (define-fun table0_initializer_57 () Bool (= (table0 #x39) s59))+[GOOD] (define-fun table0_initializer_58 () Bool (= (table0 #x3a) s60))+[GOOD] (define-fun table0_initializer_59 () Bool (= (table0 #x3b) s61))+[GOOD] (define-fun table0_initializer_60 () Bool (= (table0 #x3c) s62))+[GOOD] (define-fun table0_initializer_61 () Bool (= (table0 #x3d) s63))+[GOOD] (define-fun table0_initializer_62 () Bool (= (table0 #x3e) s64))+[GOOD] (define-fun table0_initializer_63 () Bool (= (table0 #x3f) s65))+[GOOD] (define-fun table0_initializer_64 () Bool (= (table0 #x40) s66))+[GOOD] (define-fun table0_initializer_65 () Bool (= (table0 #x41) s67))+[GOOD] (define-fun table0_initializer_66 () Bool (= (table0 #x42) s68))+[GOOD] (define-fun table0_initializer_67 () Bool (= (table0 #x43) s69))+[GOOD] (define-fun table0_initializer_68 () Bool (= (table0 #x44) s70))+[GOOD] (define-fun table0_initializer_69 () Bool (= (table0 #x45) s71))+[GOOD] (define-fun table0_initializer_70 () Bool (= (table0 #x46) s72))+[GOOD] (define-fun table0_initializer_71 () Bool (= (table0 #x47) s73))+[GOOD] (define-fun table0_initializer_72 () Bool (= (table0 #x48) s74))+[GOOD] (define-fun table0_initializer_73 () Bool (= (table0 #x49) s75))+[GOOD] (define-fun table0_initializer_74 () Bool (= (table0 #x4a) s76))+[GOOD] (define-fun table0_initializer_75 () Bool (= (table0 #x4b) s77))+[GOOD] (define-fun table0_initializer_76 () Bool (= (table0 #x4c) s78))+[GOOD] (define-fun table0_initializer_77 () Bool (= (table0 #x4d) s79))+[GOOD] (define-fun table0_initializer_78 () Bool (= (table0 #x4e) s80))+[GOOD] (define-fun table0_initializer_79 () Bool (= (table0 #x4f) s81))+[GOOD] (define-fun table0_initializer_80 () Bool (= (table0 #x50) s82))+[GOOD] (define-fun table0_initializer_81 () Bool (= (table0 #x51) s83))+[GOOD] (define-fun table0_initializer_82 () Bool (= (table0 #x52) s84))+[GOOD] (define-fun table0_initializer_83 () Bool (= (table0 #x53) s85))+[GOOD] (define-fun table0_initializer_84 () Bool (= (table0 #x54) s86))+[GOOD] (define-fun table0_initializer_85 () Bool (= (table0 #x55) s87))+[GOOD] (define-fun table0_initializer_86 () Bool (= (table0 #x56) s88))+[GOOD] (define-fun table0_initializer_87 () Bool (= (table0 #x57) s89))+[GOOD] (define-fun table0_initializer_88 () Bool (= (table0 #x58) s90))+[GOOD] (define-fun table0_initializer_89 () Bool (= (table0 #x59) s91))+[GOOD] (define-fun table0_initializer_90 () Bool (= (table0 #x5a) s92))+[GOOD] (define-fun table0_initializer_91 () Bool (= (table0 #x5b) s93))+[GOOD] (define-fun table0_initializer_92 () Bool (= (table0 #x5c) s94))+[GOOD] (define-fun table0_initializer_93 () Bool (= (table0 #x5d) s95))+[GOOD] (define-fun table0_initializer_94 () Bool (= (table0 #x5e) s96))+[GOOD] (define-fun table0_initializer_95 () Bool (= (table0 #x5f) s97))+[GOOD] (define-fun table0_initializer_96 () Bool (= (table0 #x60) s98))+[GOOD] (define-fun table0_initializer_97 () Bool (= (table0 #x61) s99))+[GOOD] (define-fun table0_initializer_98 () Bool (= (table0 #x62) s100))+[GOOD] (define-fun table0_initializer_99 () Bool (= (table0 #x63) s101))+[GOOD] (define-fun table0_initializer_100 () Bool (= (table0 #x64) s102))+[GOOD] (define-fun table0_initializer_101 () Bool (= (table0 #x65) s103))+[GOOD] (define-fun table0_initializer_102 () Bool (= (table0 #x66) s104))+[GOOD] (define-fun table0_initializer_103 () Bool (= (table0 #x67) s105))+[GOOD] (define-fun table0_initializer_104 () Bool (= (table0 #x68) s106))+[GOOD] (define-fun table0_initializer_105 () Bool (= (table0 #x69) s107))+[GOOD] (define-fun table0_initializer_106 () Bool (= (table0 #x6a) s108))+[GOOD] (define-fun table0_initializer_107 () Bool (= (table0 #x6b) s109))+[GOOD] (define-fun table0_initializer_108 () Bool (= (table0 #x6c) s110))+[GOOD] (define-fun table0_initializer_109 () Bool (= (table0 #x6d) s111))+[GOOD] (define-fun table0_initializer_110 () Bool (= (table0 #x6e) s112))+[GOOD] (define-fun table0_initializer_111 () Bool (= (table0 #x6f) s113))+[GOOD] (define-fun table0_initializer_112 () Bool (= (table0 #x70) s114))+[GOOD] (define-fun table0_initializer_113 () Bool (= (table0 #x71) s115))+[GOOD] (define-fun table0_initializer_114 () Bool (= (table0 #x72) s116))+[GOOD] (define-fun table0_initializer_115 () Bool (= (table0 #x73) s117))+[GOOD] (define-fun table0_initializer_116 () Bool (= (table0 #x74) s118))+[GOOD] (define-fun table0_initializer_117 () Bool (= (table0 #x75) s119))+[GOOD] (define-fun table0_initializer_118 () Bool (= (table0 #x76) s120))+[GOOD] (define-fun table0_initializer_119 () Bool (= (table0 #x77) s121))+[GOOD] (define-fun table0_initializer_120 () Bool (= (table0 #x78) s122))+[GOOD] (define-fun table0_initializer_121 () Bool (= (table0 #x79) s123))+[GOOD] (define-fun table0_initializer_122 () Bool (= (table0 #x7a) s124))+[GOOD] (define-fun table0_initializer_123 () Bool (= (table0 #x7b) s125))+[GOOD] (define-fun table0_initializer_124 () Bool (= (table0 #x7c) s126))+[GOOD] (define-fun table0_initializer_125 () Bool (= (table0 #x7d) s127))+[GOOD] (define-fun table0_initializer_126 () Bool (= (table0 #x7e) s128))+[GOOD] (define-fun table0_initializer_127 () Bool (= (table0 #x7f) s129))+[GOOD] (define-fun table0_initializer_128 () Bool (= (table0 #x80) s130))+[GOOD] (define-fun table0_initializer_129 () Bool (= (table0 #x81) s131))+[GOOD] (define-fun table0_initializer_130 () Bool (= (table0 #x82) s132))+[GOOD] (define-fun table0_initializer_131 () Bool (= (table0 #x83) s133))+[GOOD] (define-fun table0_initializer_132 () Bool (= (table0 #x84) s134))+[GOOD] (define-fun table0_initializer_133 () Bool (= (table0 #x85) s135))+[GOOD] (define-fun table0_initializer_134 () Bool (= (table0 #x86) s136))+[GOOD] (define-fun table0_initializer_135 () Bool (= (table0 #x87) s137))+[GOOD] (define-fun table0_initializer_136 () Bool (= (table0 #x88) s138))+[GOOD] (define-fun table0_initializer_137 () Bool (= (table0 #x89) s139))+[GOOD] (define-fun table0_initializer_138 () Bool (= (table0 #x8a) s140))+[GOOD] (define-fun table0_initializer_139 () Bool (= (table0 #x8b) s141))+[GOOD] (define-fun table0_initializer_140 () Bool (= (table0 #x8c) s142))+[GOOD] (define-fun table0_initializer_141 () Bool (= (table0 #x8d) s143))+[GOOD] (define-fun table0_initializer_142 () Bool (= (table0 #x8e) s144))+[GOOD] (define-fun table0_initializer_143 () Bool (= (table0 #x8f) s145))+[GOOD] (define-fun table0_initializer_144 () Bool (= (table0 #x90) s146))+[GOOD] (define-fun table0_initializer_145 () Bool (= (table0 #x91) s147))+[GOOD] (define-fun table0_initializer_146 () Bool (= (table0 #x92) s148))+[GOOD] (define-fun table0_initializer_147 () Bool (= (table0 #x93) s149))+[GOOD] (define-fun table0_initializer_148 () Bool (= (table0 #x94) s150))+[GOOD] (define-fun table0_initializer_149 () Bool (= (table0 #x95) s151))+[GOOD] (define-fun table0_initializer_150 () Bool (= (table0 #x96) s152))+[GOOD] (define-fun table0_initializer_151 () Bool (= (table0 #x97) s153))+[GOOD] (define-fun table0_initializer_152 () Bool (= (table0 #x98) s154))+[GOOD] (define-fun table0_initializer_153 () Bool (= (table0 #x99) s155))+[GOOD] (define-fun table0_initializer_154 () Bool (= (table0 #x9a) s156))+[GOOD] (define-fun table0_initializer_155 () Bool (= (table0 #x9b) s157))+[GOOD] (define-fun table0_initializer_156 () Bool (= (table0 #x9c) s158))+[GOOD] (define-fun table0_initializer_157 () Bool (= (table0 #x9d) s159))+[GOOD] (define-fun table0_initializer_158 () Bool (= (table0 #x9e) s160))+[GOOD] (define-fun table0_initializer_159 () Bool (= (table0 #x9f) s161))+[GOOD] (define-fun table0_initializer_160 () Bool (= (table0 #xa0) s162))+[GOOD] (define-fun table0_initializer_161 () Bool (= (table0 #xa1) s163))+[GOOD] (define-fun table0_initializer_162 () Bool (= (table0 #xa2) s164))+[GOOD] (define-fun table0_initializer_163 () Bool (= (table0 #xa3) s165))+[GOOD] (define-fun table0_initializer_164 () Bool (= (table0 #xa4) s166))+[GOOD] (define-fun table0_initializer_165 () Bool (= (table0 #xa5) s167))+[GOOD] (define-fun table0_initializer_166 () Bool (= (table0 #xa6) s168))+[GOOD] (define-fun table0_initializer_167 () Bool (= (table0 #xa7) s169))+[GOOD] (define-fun table0_initializer_168 () Bool (= (table0 #xa8) s170))+[GOOD] (define-fun table0_initializer_169 () Bool (= (table0 #xa9) s171))+[GOOD] (define-fun table0_initializer_170 () Bool (= (table0 #xaa) s172))+[GOOD] (define-fun table0_initializer_171 () Bool (= (table0 #xab) s173))+[GOOD] (define-fun table0_initializer_172 () Bool (= (table0 #xac) s174))+[GOOD] (define-fun table0_initializer_173 () Bool (= (table0 #xad) s175))+[GOOD] (define-fun table0_initializer_174 () Bool (= (table0 #xae) s176))+[GOOD] (define-fun table0_initializer_175 () Bool (= (table0 #xaf) s177))+[GOOD] (define-fun table0_initializer_176 () Bool (= (table0 #xb0) s178))+[GOOD] (define-fun table0_initializer_177 () Bool (= (table0 #xb1) s179))+[GOOD] (define-fun table0_initializer_178 () Bool (= (table0 #xb2) s180))+[GOOD] (define-fun table0_initializer_179 () Bool (= (table0 #xb3) s181))+[GOOD] (define-fun table0_initializer_180 () Bool (= (table0 #xb4) s182))+[GOOD] (define-fun table0_initializer_181 () Bool (= (table0 #xb5) s183))+[GOOD] (define-fun table0_initializer_182 () Bool (= (table0 #xb6) s184))+[GOOD] (define-fun table0_initializer_183 () Bool (= (table0 #xb7) s185))+[GOOD] (define-fun table0_initializer_184 () Bool (= (table0 #xb8) s186))+[GOOD] (define-fun table0_initializer_185 () Bool (= (table0 #xb9) s187))+[GOOD] (define-fun table0_initializer_186 () Bool (= (table0 #xba) s188))+[GOOD] (define-fun table0_initializer_187 () Bool (= (table0 #xbb) s189))+[GOOD] (define-fun table0_initializer_188 () Bool (= (table0 #xbc) s190))+[GOOD] (define-fun table0_initializer_189 () Bool (= (table0 #xbd) s191))+[GOOD] (define-fun table0_initializer_190 () Bool (= (table0 #xbe) s192))+[GOOD] (define-fun table0_initializer_191 () Bool (= (table0 #xbf) s193))+[GOOD] (define-fun table0_initializer_192 () Bool (= (table0 #xc0) s194))+[GOOD] (define-fun table0_initializer_193 () Bool (= (table0 #xc1) s195))+[GOOD] (define-fun table0_initializer_194 () Bool (= (table0 #xc2) s196))+[GOOD] (define-fun table0_initializer_195 () Bool (= (table0 #xc3) s197))+[GOOD] (define-fun table0_initializer_196 () Bool (= (table0 #xc4) s198))+[GOOD] (define-fun table0_initializer_197 () Bool (= (table0 #xc5) s199))+[GOOD] (define-fun table0_initializer_198 () Bool (= (table0 #xc6) s200))+[GOOD] (define-fun table0_initializer_199 () Bool (= (table0 #xc7) s201))+[GOOD] (define-fun table0_initializer_200 () Bool (= (table0 #xc8) s202))+[GOOD] (define-fun table0_initializer_201 () Bool (= (table0 #xc9) s203))+[GOOD] (define-fun table0_initializer_202 () Bool (= (table0 #xca) s204))+[GOOD] (define-fun table0_initializer_203 () Bool (= (table0 #xcb) s205))+[GOOD] (define-fun table0_initializer_204 () Bool (= (table0 #xcc) s206))+[GOOD] (define-fun table0_initializer_205 () Bool (= (table0 #xcd) s207))+[GOOD] (define-fun table0_initializer_206 () Bool (= (table0 #xce) s208))+[GOOD] (define-fun table0_initializer_207 () Bool (= (table0 #xcf) s209))+[GOOD] (define-fun table0_initializer_208 () Bool (= (table0 #xd0) s210))+[GOOD] (define-fun table0_initializer_209 () Bool (= (table0 #xd1) s211))+[GOOD] (define-fun table0_initializer_210 () Bool (= (table0 #xd2) s212))+[GOOD] (define-fun table0_initializer_211 () Bool (= (table0 #xd3) s213))+[GOOD] (define-fun table0_initializer_212 () Bool (= (table0 #xd4) s214))+[GOOD] (define-fun table0_initializer_213 () Bool (= (table0 #xd5) s215))+[GOOD] (define-fun table0_initializer_214 () Bool (= (table0 #xd6) s216))+[GOOD] (define-fun table0_initializer_215 () Bool (= (table0 #xd7) s217))+[GOOD] (define-fun table0_initializer_216 () Bool (= (table0 #xd8) s218))+[GOOD] (define-fun table0_initializer_217 () Bool (= (table0 #xd9) s219))+[GOOD] (define-fun table0_initializer_218 () Bool (= (table0 #xda) s220))+[GOOD] (define-fun table0_initializer_219 () Bool (= (table0 #xdb) s221))+[GOOD] (define-fun table0_initializer_220 () Bool (= (table0 #xdc) s222))+[GOOD] (define-fun table0_initializer_221 () Bool (= (table0 #xdd) s223))+[GOOD] (define-fun table0_initializer_222 () Bool (= (table0 #xde) s224))+[GOOD] (define-fun table0_initializer_223 () Bool (= (table0 #xdf) s225))+[GOOD] (define-fun table0_initializer_224 () Bool (= (table0 #xe0) s226))+[GOOD] (define-fun table0_initializer_225 () Bool (= (table0 #xe1) s227))+[GOOD] (define-fun table0_initializer_226 () Bool (= (table0 #xe2) s228))+[GOOD] (define-fun table0_initializer_227 () Bool (= (table0 #xe3) s229))+[GOOD] (define-fun table0_initializer_228 () Bool (= (table0 #xe4) s230))+[GOOD] (define-fun table0_initializer_229 () Bool (= (table0 #xe5) s231))+[GOOD] (define-fun table0_initializer_230 () Bool (= (table0 #xe6) s232))+[GOOD] (define-fun table0_initializer_231 () Bool (= (table0 #xe7) s233))+[GOOD] (define-fun table0_initializer_232 () Bool (= (table0 #xe8) s234))+[GOOD] (define-fun table0_initializer_233 () Bool (= (table0 #xe9) s235))+[GOOD] (define-fun table0_initializer_234 () Bool (= (table0 #xea) s236))+[GOOD] (define-fun table0_initializer_235 () Bool (= (table0 #xeb) s237))+[GOOD] (define-fun table0_initializer_236 () Bool (= (table0 #xec) s238))+[GOOD] (define-fun table0_initializer_237 () Bool (= (table0 #xed) s239))+[GOOD] (define-fun table0_initializer_238 () Bool (= (table0 #xee) s240))+[GOOD] (define-fun table0_initializer_239 () Bool (= (table0 #xef) s241))+[GOOD] (define-fun table0_initializer_240 () Bool (= (table0 #xf0) s242))+[GOOD] (define-fun table0_initializer_241 () Bool (= (table0 #xf1) s243))+[GOOD] (define-fun table0_initializer_242 () Bool (= (table0 #xf2) s244))+[GOOD] (define-fun table0_initializer_243 () Bool (= (table0 #xf3) s245))+[GOOD] (define-fun table0_initializer_244 () Bool (= (table0 #xf4) s246))+[GOOD] (define-fun table0_initializer_245 () Bool (= (table0 #xf5) s247))+[GOOD] (define-fun table0_initializer_246 () Bool (= (table0 #xf6) s248))+[GOOD] (define-fun table0_initializer_247 () Bool (= (table0 #xf7) s249))+[GOOD] (define-fun table0_initializer_248 () Bool (= (table0 #xf8) s250))+[GOOD] (define-fun table0_initializer_249 () Bool (= (table0 #xf9) s251))+[GOOD] (define-fun table0_initializer_250 () Bool (= (table0 #xfa) s252))+[GOOD] (define-fun table0_initializer_251 () Bool (= (table0 #xfb) s253))+[GOOD] (define-fun table0_initializer_252 () Bool (= (table0 #xfc) s254))+[GOOD] (define-fun table0_initializer_253 () Bool (= (table0 #xfd) s255))+[GOOD] (define-fun table0_initializer_254 () Bool (= (table0 #xfe) s256))+[GOOD] (define-fun table0_initializer_255 () Bool (= (table0 #xff) s257))+[GOOD] (define-fun table0_initializer () Bool (and table0_initializer_0 table0_initializer_1 table0_initializer_2 table0_initializer_3 table0_initializer_4 table0_initializer_5 table0_initializer_6 table0_initializer_7 table0_initializer_8 table0_initializer_9 table0_initializer_10 table0_initializer_11 table0_initializer_12 table0_initializer_13 table0_initializer_14 table0_initializer_15 table0_initializer_16 table0_initializer_17 table0_initializer_18 table0_initializer_19 table0_initializer_20 table0_initializer_21 table0_initializer_22 table0_initializer_23 table0_initializer_24 table0_initializer_25 table0_initializer_26 table0_initializer_27 table0_initializer_28 table0_initializer_29 table0_initializer_30 table0_initializer_31 table0_initializer_32 table0_initializer_33 table0_initializer_34 table0_initializer_35 table0_initializer_36 table0_initializer_37 table0_initializer_38 table0_initializer_39 table0_initializer_40 table0_initializer_41 table0_initializer_42 table0_initializer_43 table0_initializer_44 table0_initializer_45 table0_initializer_46 table0_initializer_47 table0_initializer_48 table0_initializer_49 table0_initializer_50 table0_initializer_51 table0_initializer_52 table0_initializer_53 table0_initializer_54 table0_initializer_55 table0_initializer_56 table0_initializer_57 table0_initializer_58 table0_initializer_59 table0_initializer_60 table0_initializer_61 table0_initializer_62 table0_initializer_63 table0_initializer_64 table0_initializer_65 table0_initializer_66 table0_initializer_67 table0_initializer_68 table0_initializer_69 table0_initializer_70 table0_initializer_71 table0_initializer_72 table0_initializer_73 table0_initializer_74 table0_initializer_75 table0_initializer_76 table0_initializer_77 table0_initializer_78 table0_initializer_79 table0_initializer_80 table0_initializer_81 table0_initializer_82 table0_initializer_83 table0_initializer_84 table0_initializer_85 table0_initializer_86 table0_initializer_87 table0_initializer_88 table0_initializer_89 table0_initializer_90 table0_initializer_91 table0_initializer_92 table0_initializer_93 table0_initializer_94 table0_initializer_95 table0_initializer_96 table0_initializer_97 table0_initializer_98 table0_initializer_99 table0_initializer_100 table0_initializer_101 table0_initializer_102 table0_initializer_103 table0_initializer_104 table0_initializer_105 table0_initializer_106 table0_initializer_107 table0_initializer_108 table0_initializer_109 table0_initializer_110 table0_initializer_111 table0_initializer_112 table0_initializer_113 table0_initializer_114 table0_initializer_115 table0_initializer_116 table0_initializer_117 table0_initializer_118 table0_initializer_119 table0_initializer_120 table0_initializer_121 table0_initializer_122 table0_initializer_123 table0_initializer_124 table0_initializer_125 table0_initializer_126 table0_initializer_127 table0_initializer_128 table0_initializer_129 table0_initializer_130 table0_initializer_131 table0_initializer_132 table0_initializer_133 table0_initializer_134 table0_initializer_135 table0_initializer_136 table0_initializer_137 table0_initializer_138 table0_initializer_139 table0_initializer_140 table0_initializer_141 table0_initializer_142 table0_initializer_143 table0_initializer_144 table0_initializer_145 table0_initializer_146 table0_initializer_147 table0_initializer_148 table0_initializer_149 table0_initializer_150 table0_initializer_151 table0_initializer_152 table0_initializer_153 table0_initializer_154 table0_initializer_155 table0_initializer_156 table0_initializer_157 table0_initializer_158 table0_initializer_159 table0_initializer_160 table0_initializer_161 table0_initializer_162 table0_initializer_163 table0_initializer_164 table0_initializer_165 table0_initializer_166 table0_initializer_167 table0_initializer_168 table0_initializer_169 table0_initializer_170 table0_initializer_171 table0_initializer_172 table0_initializer_173 table0_initializer_174 table0_initializer_175 table0_initializer_176 table0_initializer_177 table0_initializer_178 table0_initializer_179 table0_initializer_180 table0_initializer_181 table0_initializer_182 table0_initializer_183 table0_initializer_184 table0_initializer_185 table0_initializer_186 table0_initializer_187 table0_initializer_188 table0_initializer_189 table0_initializer_190 table0_initializer_191 table0_initializer_192 table0_initializer_193 table0_initializer_194 table0_initializer_195 table0_initializer_196 table0_initializer_197 table0_initializer_198 table0_initializer_199 table0_initializer_200 table0_initializer_201 table0_initializer_202 table0_initializer_203 table0_initializer_204 table0_initializer_205 table0_initializer_206 table0_initializer_207 table0_initializer_208 table0_initializer_209 table0_initializer_210 table0_initializer_211 table0_initializer_212 table0_initializer_213 table0_initializer_214 table0_initializer_215 table0_initializer_216 table0_initializer_217 table0_initializer_218 table0_initializer_219 table0_initializer_220 table0_initializer_221 table0_initializer_222 table0_initializer_223 table0_initializer_224 table0_initializer_225 table0_initializer_226 table0_initializer_227 table0_initializer_228 table0_initializer_229 table0_initializer_230 table0_initializer_231 table0_initializer_232 table0_initializer_233 table0_initializer_234 table0_initializer_235 table0_initializer_236 table0_initializer_237 table0_initializer_238 table0_initializer_239 table0_initializer_240 table0_initializer_241 table0_initializer_242 table0_initializer_243 table0_initializer_244 table0_initializer_245 table0_initializer_246 table0_initializer_247 table0_initializer_248 table0_initializer_249 table0_initializer_250 table0_initializer_251 table0_initializer_252 table0_initializer_253 table0_initializer_254 table0_initializer_255))+[GOOD] (assert table0_initializer) [GOOD] (define-fun s258 () (_ BitVec 8) (table0 s0)) [GOOD] (define-fun s259 () Bool (= s0 s258)) [GOOD] (assert s259)
SBVTestSuite/GoldFiles/queryArrays5.gold view
@@ -20,6 +20,7 @@ [GOOD] ; --- uninterpreted constants --- [GOOD] ; --- user given axioms --- [GOOD] ; --- formula ---+[GOOD] (define-fun array_0_initializer () Bool true) ; no initializiation needed [GOOD] (define-fun s2 () (_ BitVec 8) #x01) [GOOD] (define-fun s4 () (_ BitVec 8) #x01) [GOOD] (declare-fun array_1 () (Array (_ BitVec 8) (_ BitVec 8)))@@ -28,8 +29,12 @@ [GOOD] (define-fun s5 () (_ BitVec 8) (bvadd s0 s4)) [GOOD] (define-fun s6 () (_ BitVec 8) (select array_2 s5)) [GOOD] (define-fun s7 () Bool (distinct s3 s6))-[GOOD] (assert (= array_1 (store array_0 s0 s1)))-[GOOD] (assert (= array_2 (store array_1 s5 s3)))+[GOOD] (define-fun array_1_initializer_0 () Bool (= array_1 (store array_0 s0 s1)))+[GOOD] (define-fun array_2_initializer_0 () Bool (= array_2 (store array_1 s5 s3)))+[GOOD] (define-fun array_1_initializer () Bool array_1_initializer_0)+[GOOD] (assert array_1_initializer)+[GOOD] (define-fun array_2_initializer () Bool array_2_initializer_0)+[GOOD] (assert array_2_initializer) [GOOD] (assert s7) [SEND] (check-sat) [RECV] unsat
SBVTestSuite/GoldFiles/queryArrays6.gold view
@@ -18,6 +18,7 @@ [GOOD] ; --- uninterpreted constants --- [GOOD] ; --- user given axioms --- [GOOD] ; --- formula ---+[GOOD] (define-fun array_0_initializer () Bool true) ; no initializiation needed [GOOD] (push 1) [GOOD] (define-fun s0 () Int 1) [GOOD] (define-fun s2 () Int 5)@@ -31,7 +32,7 @@ [SEND] (check-sat) [RECV] unsat [GOOD] (pop 1)-[GOOD] (assert array_1_initializer)+[GOOD] (assert (and array_0_initializer array_1_initializer)) [GOOD] (declare-fun s4 () Int) [GOOD] (define-fun s6 () Int 3) [GOOD] (define-fun s5 () Bool (>= s4 s0))@@ -50,7 +51,7 @@ [SEND] (check-sat) [RECV] unsat [GOOD] (pop 1)-[GOOD] (assert (and array_1_initializer array_2_initializer))+[GOOD] (assert (and array_0_initializer array_1_initializer array_2_initializer)) [GOOD] (declare-fun s12 () Int) [GOOD] (define-fun s13 () Bool (>= s12 s0)) [GOOD] (define-fun s14 () Bool (< s12 s6))
+ SBVTestSuite/GoldFiles/queryArrays7.gold view
@@ -0,0 +1,43 @@+** Calling: z3 -nw -in -smt2+[GOOD] ; Automatically generated by SBV. Do not edit.+[GOOD] (set-option :print-success true)+[GOOD] (set-option :global-declarations true)+[GOOD] (set-option :smtlib2_compliant true)+[GOOD] (set-option :diagnostic-output-channel "stdout")+[GOOD] (set-option :produce-models true)+[GOOD] (set-logic ALL) ; has unbounded values, using catch-all.+[GOOD] ; --- uninterpreted sorts ---+[GOOD] ; --- tuples ---+[GOOD] ; --- sums ---+[GOOD] ; --- literal constants ---+[GOOD] ; --- skolem constants ---+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] (declare-fun array_0 () (Array Int Int))+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (define-fun array_0_initializer () Bool true) ; no initializiation needed+[GOOD] (define-fun s0 () Int 0)+[GOOD] (define-fun s1 () Int 1)+[GOOD] (define-fun s3 () Int 2)+[GOOD] (declare-fun array_1 () (Array Int Int))+[GOOD] (define-fun array_1_initializer_0 () Bool (= array_1 (store array_0 s0 s1)))+[GOOD] (define-fun s2 () Int (select array_1 s0))+[GOOD] (define-fun s4 () Bool (= s2 s3))+[GOOD] (define-fun array_1_initializer () Bool array_1_initializer_0)+[GOOD] (assert array_1_initializer)+[GOOD] (assert s4)+[SEND] (check-sat)+[RECV] unsat+[GOOD] (reset-assertions)+[GOOD] (assert (and array_0_initializer array_1_initializer))+[GOOD] (assert s4)+[SEND] (check-sat)+[RECV] unsat+*** Solver   : Z3+*** Exit code: ExitSuccess++ FINAL:(Unsat,Unsat)+DONE!
+ SBVTestSuite/GoldFiles/queryArrays8.gold view
@@ -0,0 +1,43 @@+** Calling: z3 -nw -in -smt2+[GOOD] ; Automatically generated by SBV. Do not edit.+[GOOD] (set-option :print-success true)+[GOOD] (set-option :global-declarations true)+[GOOD] (set-option :smtlib2_compliant true)+[GOOD] (set-option :diagnostic-output-channel "stdout")+[GOOD] (set-option :produce-models true)+[GOOD] (set-logic ALL) ; external query, using all logics.+[GOOD] ; --- uninterpreted sorts ---+[GOOD] ; --- tuples ---+[GOOD] ; --- sums ---+[GOOD] ; --- literal constants ---+[GOOD] ; --- skolem constants ---+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (declare-fun array_0 () (Array Int Int))+[GOOD] (define-fun array_0_initializer () Bool true) ; no initializiation needed+[GOOD] (define-fun s0 () Int 0)+[GOOD] (define-fun s1 () Int 1)+[GOOD] (define-fun s3 () Int 2)+[GOOD] (declare-fun array_1 () (Array Int Int))+[GOOD] (define-fun array_1_initializer_0 () Bool (= array_1 (store array_0 s0 s1)))+[GOOD] (define-fun s2 () Int (select array_1 s0))+[GOOD] (define-fun s4 () Bool (= s2 s3))+[GOOD] (define-fun array_1_initializer () Bool array_1_initializer_0)+[GOOD] (assert array_1_initializer)+[GOOD] (assert s4)+[SEND] (check-sat)+[RECV] unsat+[GOOD] (reset-assertions)+[GOOD] (assert (and array_0_initializer array_1_initializer))+[GOOD] (assert s4)+[SEND] (check-sat)+[RECV] unsat+*** Solver   : Z3+*** Exit code: ExitSuccess++ FINAL:(Unsat,Unsat)+DONE!
SBVTestSuite/GoldFiles/query_Interpolant1.gold view
@@ -1,8 +1,7 @@ ** Calling: mathsat -input=smt2 -theory.fp.minmax_zero_mode=4 [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true)-** Backend solver MathSAT does not support global decls.-** Some incremental calls, such as pop, will be limited.+[GOOD] (set-option :global-declarations true) [GOOD] (set-option :diagnostic-output-channel "stdout") [GOOD] (set-option :produce-interpolants true) [GOOD] (set-option :produce-models true)
SBVTestSuite/GoldFiles/query_Interpolant2.gold view
@@ -1,8 +1,7 @@ ** Calling: mathsat -input=smt2 -theory.fp.minmax_zero_mode=4 [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true)-** Backend solver MathSAT does not support global decls.-** Some incremental calls, such as pop, will be limited.+[GOOD] (set-option :global-declarations true) [GOOD] (set-option :diagnostic-output-channel "stdout") [GOOD] (set-option :produce-interpolants true) [GOOD] (set-option :produce-models true)
SBVTestSuite/GoldFiles/query_cvc4.gold view
@@ -1,4 +1,4 @@-** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true)
SBVTestSuite/GoldFiles/query_mathsat.gold view
@@ -1,8 +1,7 @@ ** Calling: mathsat -input=smt2 -theory.fp.minmax_zero_mode=4 [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true)-** Backend solver MathSAT does not support global decls.-** Some incremental calls, such as pop, will be limited.+[GOOD] (set-option :global-declarations true) [GOOD] (set-option :diagnostic-output-channel "stdout") [GOOD] (set-option :produce-models true) [GOOD] (set-logic ALL) ; external query, using all logics.
SBVTestSuite/GoldFiles/query_uiSat_test2.gold view
@@ -31,7 +31,7 @@ [GOOD] (set-option :pp.min_alias_size 4294967295) [GOOD] (set-option :model.inline_def  true      ) [SEND] (get-value (q2))-[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (or (and x!2 x!1) (and x!2 (not x!1))))))+[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (or (and x!1 x!2) (and x!1 (not x!2)))))) [SEND] (get-value ((q2 false false))) [RECV] (((q2 false false) false)) [SEND] (get-value ((q2 false true)))
SBVTestSuite/GoldFiles/set_tupleSet.gold view
@@ -30,11 +30,11 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (s0))-[RECV] ((s0 (mkSBVTuple2 (lambda ((x!1 Bool)) (not x!1)) (lambda ((x!1 Bool)) x!1))))+[RECV] ((s0 (mkSBVTuple2 (lambda ((x!1 Bool)) x!1) (lambda ((x!1 Bool)) (not x!1))))) *** Solver   : Z3 *** Exit code: ExitSuccess  FINAL: Satisfiable. Model:-  s0 = (U - {True},{True}) :: ({Bool}, {Bool})+  s0 = ({True},U - {True}) :: ({Bool}, {Bool}) DONE!
SBVTestSuite/GoldFiles/set_uninterp1.gold view
@@ -75,8 +75,8 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (s0))-[RECV] ((s0 (lambda ((x!1 E)) (= x!1 B))))-[GOOD] (define-fun s16 () (Array E Bool) (store ((as const (Array E Bool)) false) B true))+[RECV] ((s0 (store (store ((as const (Array E Bool)) false) C true) B true)))+[GOOD] (define-fun s16 () (Array E Bool) (store (store ((as const (Array E Bool)) false) C true) B true)) [GOOD] (define-fun s17 () Bool (= s0 s16)) [GOOD] (define-fun s18 () Bool (not s17)) [GOOD] (assert s18)@@ -93,8 +93,8 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (s0))-[RECV] ((s0 (store (store ((as const (Array E Bool)) false) C true) B true)))-[GOOD] (define-fun s22 () (Array E Bool) (store (store ((as const (Array E Bool)) false) C true) B true))+[RECV] ((s0 (lambda ((x!1 E)) (= x!1 B))))+[GOOD] (define-fun s22 () (Array E Bool) (store ((as const (Array E Bool)) false) B true)) [GOOD] (define-fun s23 () Bool (= s0 s22)) [GOOD] (define-fun s24 () Bool (not s23)) [GOOD] (assert s24)@@ -116,10 +116,10 @@ Solution #5:   s0 = {A,C} :: {E} Solution #6:-  s0 = {B} :: {E}+  s0 = {B,C} :: {E} Solution #7:   s0 = {C} :: {E} Solution #8:-  s0 = {B,C} :: {E}+  s0 = {B} :: {E} Found 8 different solutions. DONE!
SBVTestSuite/GoldFiles/tuple_swap.gold view
@@ -17,6 +17,10 @@                                                          (proj_3_SBVTuple3 T3)))))) [GOOD] ; --- sums --- [GOOD] ; --- literal constants ---+[GOOD] (define-fun s8 () Int 1)+[GOOD] (define-fun s10 () Int 2)+[GOOD] (define-fun s13 () Int 3)+[GOOD] (define-fun s16 () Int 4) [GOOD] ; --- skolem constants --- [GOOD] (declare-fun s0 () (SBVTuple3 Int Int Int)) ; tracks user variable "abx" [GOOD] (declare-fun s1 () (SBVTuple3 Int Int Int)) ; tracks user variable "bay"@@ -32,16 +36,26 @@ [GOOD] (define-fun s5 () Int (proj_2_SBVTuple3 s0)) [GOOD] (define-fun s6 () Int (proj_1_SBVTuple3 s1)) [GOOD] (define-fun s7 () Bool (= s5 s6))+[GOOD] (define-fun s9 () Bool (= s2 s8))+[GOOD] (define-fun s11 () Bool (= s5 s10))+[GOOD] (define-fun s12 () Int (proj_3_SBVTuple3 s0))+[GOOD] (define-fun s14 () Bool (= s12 s13))+[GOOD] (define-fun s15 () Int (proj_3_SBVTuple3 s1))+[GOOD] (define-fun s17 () Bool (= s15 s16)) [GOOD] (assert s4) [GOOD] (assert s7)+[GOOD] (assert s9)+[GOOD] (assert s11)+[GOOD] (assert s14)+[GOOD] (assert s17) [SEND] (check-sat) [RECV] sat [SEND] (get-value (s0))-[RECV] ((s0 (mkSBVTuple3 0 7719 1)))+[RECV] ((s0 (mkSBVTuple3 1 2 3))) [SEND] (get-value (s1))-[RECV] ((s1 (mkSBVTuple3 7719 0 2)))+[RECV] ((s1 (mkSBVTuple3 2 1 4))) *** Solver   : Z3 *** Exit code: ExitSuccess - FINAL: ((0,7719,1),(7719,0,2))+ FINAL: ((1,2,3),(2,1,4)) DONE!
SBVTestSuite/GoldFiles/uiSat_test2.gold view
@@ -70,7 +70,7 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q2))-[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and (not x!2) x!1))))+[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and (not x!1) x!2)))) [SEND] (get-value ((q2 false false))) [RECV] (((q2 false false) false)) [SEND] (get-value ((q2 false true)))@@ -93,7 +93,7 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q2))-[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and x!2 x!1))))+[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and x!1 x!2)))) [SEND] (get-value ((q2 false false))) [RECV] (((q2 false false) false)) [SEND] (get-value ((q2 false true)))@@ -116,7 +116,7 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q2))-[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (or (and x!2 x!1) (and x!2 (not x!1))))))+[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (or (and x!1 x!2) (and x!1 (not x!2)))))) [SEND] (get-value ((q2 false false))) [RECV] (((q2 false false) false)) [SEND] (get-value ((q2 false true)))@@ -140,7 +140,7 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q2))-[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and x!2 (not x!1)))))+[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and x!1 (not x!2))))) [SEND] (get-value ((q2 false false))) [RECV] (((q2 false false) false)) [SEND] (get-value ((q2 false true)))@@ -163,7 +163,7 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q2))-[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (or (and (not x!2) x!1) (and x!2 (not x!1))))))+[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (or (and (not x!1) x!2) (and x!1 (not x!2)))))) [SEND] (get-value ((q2 false false))) [RECV] (((q2 false false) false)) [SEND] (get-value ((q2 false true)))@@ -187,7 +187,7 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q2))-[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (or (and x!2 x!1) (and (not x!2) x!1)))))+[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (or (and x!1 x!2) (and (not x!1) x!2))))) [SEND] (get-value ((q2 false false))) [RECV] (((q2 false false) false)) [SEND] (get-value ((q2 false true)))@@ -211,18 +211,10 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q2))-[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and (not x!2) (not x!1)))))-[SEND] (get-value ((q2 false false)))-[RECV] (((q2 false false) true))-[SEND] (get-value ((q2 false true)))-[RECV] (((q2 false true) false))-[SEND] (get-value ((q2 true false)))-[RECV] (((q2 true false) false))-[SEND] (get-value ((q2 true true)))-[RECV] (((q2 true true) false))+[RECV] ((q2 (store ((as const Array) true) false true false))) [GOOD] (define-fun q2_model10 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 false) (= x!1 false)) true-          false)+          (ite (and (= x!0 false) (= x!1 true)) false+          true)        ) [GOOD] (define-fun q2_model10_reject () Bool           (exists ((x!0 Bool) (x!1 Bool))@@ -234,10 +226,11 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q2))-[RECV] ((q2 (store ((as const Array) true) false true false)))+[RECV] ((q2 (store (store ((as const Array) true) false true false) true true false))) [GOOD] (define-fun q2_model11 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 true) (= x!1 true)) false           (ite (and (= x!0 false) (= x!1 true)) false-          true)+          true))        ) [GOOD] (define-fun q2_model11_reject () Bool           (exists ((x!0 Bool) (x!1 Bool))@@ -249,11 +242,18 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q2))-[RECV] ((q2 (store (store ((as const Array) true) false true false) true false false)))+[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and (not x!1) (not x!2)))))+[SEND] (get-value ((q2 false false)))+[RECV] (((q2 false false) true))+[SEND] (get-value ((q2 false true)))+[RECV] (((q2 false true) false))+[SEND] (get-value ((q2 true false)))+[RECV] (((q2 true false) false))+[SEND] (get-value ((q2 true true)))+[RECV] (((q2 true true) false)) [GOOD] (define-fun q2_model12 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 true) (= x!1 false)) false-          (ite (and (= x!0 false) (= x!1 true)) false-          true))+          (ite (and (= x!0 false) (= x!1 false)) true+          false)        ) [GOOD] (define-fun q2_model12_reject () Bool           (exists ((x!0 Bool) (x!1 Bool))@@ -265,19 +265,18 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q2))-[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool))-         (or (and (not x!2) (not x!1)) (and x!2 (not x!1))))))+[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (or (and x!1 x!2) (and (not x!1) (not x!2)))))) [SEND] (get-value ((q2 false false))) [RECV] (((q2 false false) true)) [SEND] (get-value ((q2 false true))) [RECV] (((q2 false true) false)) [SEND] (get-value ((q2 true false)))-[RECV] (((q2 true false) true))+[RECV] (((q2 true false) false)) [SEND] (get-value ((q2 true true)))-[RECV] (((q2 true true) false))+[RECV] (((q2 true true) true)) [GOOD] (define-fun q2_model13 ((x!0 Bool) (x!1 Bool)) Bool           (ite (and (= x!0 false) (= x!1 false)) true-          (ite (and (= x!0 true) (= x!1 false)) true+          (ite (and (= x!0 true) (= x!1 true)) true           false))        ) [GOOD] (define-fun q2_model13_reject () Bool@@ -290,10 +289,20 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q2))-[RECV] ((q2 (store ((as const Array) true) true false false)))+[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool))+         (or (and (not x!1) (not x!2)) (and (not x!1) x!2)))))+[SEND] (get-value ((q2 false false)))+[RECV] (((q2 false false) true))+[SEND] (get-value ((q2 false true)))+[RECV] (((q2 false true) true))+[SEND] (get-value ((q2 true false)))+[RECV] (((q2 true false) false))+[SEND] (get-value ((q2 true true)))+[RECV] (((q2 true true) false)) [GOOD] (define-fun q2_model14 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 true) (= x!1 false)) false-          true)+          (ite (and (= x!0 false) (= x!1 false)) true+          (ite (and (= x!0 false) (= x!1 true)) true+          false))        ) [GOOD] (define-fun q2_model14_reject () Bool           (exists ((x!0 Bool) (x!1 Bool))@@ -305,11 +314,10 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q2))-[RECV] ((q2 (store (store ((as const Array) true) true false false) true true false)))+[RECV] ((q2 (store ((as const Array) true) true true false))) [GOOD] (define-fun q2_model15 ((x!0 Bool) (x!1 Bool)) Bool           (ite (and (= x!0 true) (= x!1 true)) false-          (ite (and (= x!0 true) (= x!1 false)) false-          true))+          true)        ) [GOOD] (define-fun q2_model15_reject () Bool           (exists ((x!0 Bool) (x!1 Bool))@@ -321,9 +329,9 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q2))-[RECV] ((q2 (store ((as const Array) true) true true false)))+[RECV] ((q2 (store ((as const Array) true) true false false))) [GOOD] (define-fun q2_model16 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 true) (= x!1 true)) false+          (ite (and (= x!0 true) (= x!1 false)) false           true)        ) [GOOD] (define-fun q2_model16_reject () Bool@@ -377,33 +385,33 @@   q2 _     _    = False Solution #10:   q2 :: Bool -> Bool -> Bool-  q2 False False = True -  q2 _     _     = False+  q2 False True = False+  q2 _     _    = True  Solution #11:   q2 :: Bool -> Bool -> Bool+  q2 True  True = False   q2 False True = False   q2 _     _    = True  Solution #12:   q2 :: Bool -> Bool -> Bool-  q2 True  False = False-  q2 False True  = False-  q2 _     _     = True +  q2 False False = True +  q2 _     _     = False Solution #13:   q2 :: Bool -> Bool -> Bool   q2 False False = True -  q2 True  False = True +  q2 True  True  = True    q2 _     _     = False Solution #14:   q2 :: Bool -> Bool -> Bool-  q2 True False = False-  q2 _    _     = True +  q2 False False = True +  q2 False True  = True +  q2 _     _     = False Solution #15:   q2 :: Bool -> Bool -> Bool-  q2 True True  = False-  q2 True False = False-  q2 _    _     = True -Solution #16:-  q2 :: Bool -> Bool -> Bool   q2 True True = False   q2 _    _    = True +Solution #16:+  q2 :: Bool -> Bool -> Bool+  q2 True False = False+  q2 _    _     = True  Found 16 different solutions.
SBVTestSuite/GoldFiles/uiSat_test3.gold view
@@ -164,2378 +164,2387 @@ [SEND] (get-value (q1)) [RECV] ((q1 (lambda ((x!1 Bool)) x!1))) [SEND] (get-value (q2))-[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and (not x!2) (not x!1)))))-[SEND] (get-value ((q2 false false)))-[RECV] (((q2 false false) true))-[SEND] (get-value ((q2 false true)))-[RECV] (((q2 false true) false))-[SEND] (get-value ((q2 true false)))-[RECV] (((q2 true false) false))-[SEND] (get-value ((q2 true true)))-[RECV] (((q2 true true) false))-[GOOD] (define-fun q1_model6 ((x!0 Bool)) Bool-          (ite (and (= x!0 true)) true-          false)-       )-[GOOD] (define-fun q1_model6_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1        x!0)-                            (q1_model6 x!0))))-[GOOD] (define-fun q2_model6 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 false) (= x!1 false)) true-          false)-       )-[GOOD] (define-fun q2_model6_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2        x!0 x!1)-                            (q2_model6 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_6 () Bool -               (or q1_model6_reject-                   q2_model6_reject-               ))-[GOOD] (assert uiFunRejector_model_6)-Looking for solution 7-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 (lambda ((x!1 Bool)) x!1)))-[SEND] (get-value (q2))-[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (or (and x!2 x!1) (and (not x!2) (not x!1))))))-[SEND] (get-value ((q2 false false)))-[RECV] (((q2 false false) true))-[SEND] (get-value ((q2 false true)))-[RECV] (((q2 false true) false))-[SEND] (get-value ((q2 true false)))-[RECV] (((q2 true false) false))-[SEND] (get-value ((q2 true true)))-[RECV] (((q2 true true) true))-[GOOD] (define-fun q1_model7 ((x!0 Bool)) Bool-          (ite (and (= x!0 true)) true-          false)-       )-[GOOD] (define-fun q1_model7_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1        x!0)-                            (q1_model7 x!0))))-[GOOD] (define-fun q2_model7 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 false) (= x!1 false)) true-          (ite (and (= x!0 true) (= x!1 true)) true-          false))-       )-[GOOD] (define-fun q2_model7_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2        x!0 x!1)-                            (q2_model7 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_7 () Bool -               (or q1_model7_reject-                   q2_model7_reject-               ))-[GOOD] (assert uiFunRejector_model_7)-Looking for solution 8-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 ((as const Array) false)))-[SEND] (get-value (q2))-[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (or (and x!2 x!1) (and (not x!2) (not x!1))))))-[SEND] (get-value ((q2 false false)))-[RECV] (((q2 false false) true))-[SEND] (get-value ((q2 false true)))-[RECV] (((q2 false true) false))-[SEND] (get-value ((q2 true false)))-[RECV] (((q2 true false) false))-[SEND] (get-value ((q2 true true)))-[RECV] (((q2 true true) true))-[GOOD] (define-fun q1_model8 ((x!0 Bool)) Bool-          false-       )-[GOOD] (define-fun q1_model8_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1        x!0)-                            (q1_model8 x!0))))-[GOOD] (define-fun q2_model8 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 false) (= x!1 false)) true-          (ite (and (= x!0 true) (= x!1 true)) true-          false))-       )-[GOOD] (define-fun q2_model8_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2        x!0 x!1)-                            (q2_model8 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_8 () Bool -               (or q1_model8_reject-                   q2_model8_reject-               ))-[GOOD] (assert uiFunRejector_model_8)-Looking for solution 9-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 (lambda ((x!1 Bool)) (not x!1))))-[SEND] (get-value (q2))-[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (or (and x!2 x!1) (and (not x!2) (not x!1))))))-[SEND] (get-value ((q2 false false)))-[RECV] (((q2 false false) true))-[SEND] (get-value ((q2 false true)))-[RECV] (((q2 false true) false))-[SEND] (get-value ((q2 true false)))-[RECV] (((q2 true false) false))-[SEND] (get-value ((q2 true true)))-[RECV] (((q2 true true) true))-[GOOD] (define-fun q1_model9 ((x!0 Bool)) Bool-          (ite (and (= x!0 true)) false-          true)-       )-[GOOD] (define-fun q1_model9_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1        x!0)-                            (q1_model9 x!0))))-[GOOD] (define-fun q2_model9 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 false) (= x!1 false)) true-          (ite (and (= x!0 true) (= x!1 true)) true-          false))-       )-[GOOD] (define-fun q2_model9_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2        x!0 x!1)-                            (q2_model9 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_9 () Bool -               (or q1_model9_reject-                   q2_model9_reject-               ))-[GOOD] (assert uiFunRejector_model_9)-Looking for solution 10-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 ((as const Array) false)))-[SEND] (get-value (q2))-[RECV] ((q2 (store ((as const Array) true) false true false)))-[GOOD] (define-fun q1_model10 ((x!0 Bool)) Bool-          false-       )-[GOOD] (define-fun q1_model10_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model10 x!0))))-[GOOD] (define-fun q2_model10 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 false) (= x!1 true)) false-          true)-       )-[GOOD] (define-fun q2_model10_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model10 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_10 () Bool -               (or q1_model10_reject-                   q2_model10_reject-               ))-[GOOD] (assert uiFunRejector_model_10)-Looking for solution 11-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 (lambda ((x!1 Bool)) (not x!1))))-[SEND] (get-value (q2))-[RECV] ((q2 (store ((as const Array) true) false true false)))-[GOOD] (define-fun q1_model11 ((x!0 Bool)) Bool-          (ite (and (= x!0 true)) false-          true)-       )-[GOOD] (define-fun q1_model11_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model11 x!0))))-[GOOD] (define-fun q2_model11 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 false) (= x!1 true)) false-          true)-       )-[GOOD] (define-fun q2_model11_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model11 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_11 () Bool -               (or q1_model11_reject-                   q2_model11_reject-               ))-[GOOD] (assert uiFunRejector_model_11)-Looking for solution 12-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 ((as const Array) true)))-[SEND] (get-value (q2))-[RECV] ((q2 (store ((as const Array) true) false true false)))-[GOOD] (define-fun q1_model12 ((x!0 Bool)) Bool-          true-       )-[GOOD] (define-fun q1_model12_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model12 x!0))))-[GOOD] (define-fun q2_model12 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 false) (= x!1 true)) false-          true)-       )-[GOOD] (define-fun q2_model12_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model12 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_12 () Bool -               (or q1_model12_reject-                   q2_model12_reject-               ))-[GOOD] (assert uiFunRejector_model_12)-Looking for solution 13-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 ((as const Array) true)))-[SEND] (get-value (q2))-[RECV] ((q2 (store (store ((as const Array) true) false true false) true false false)))-[GOOD] (define-fun q1_model13 ((x!0 Bool)) Bool-          true-       )-[GOOD] (define-fun q1_model13_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model13 x!0))))-[GOOD] (define-fun q2_model13 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 true) (= x!1 false)) false-          (ite (and (= x!0 false) (= x!1 true)) false-          true))-       )-[GOOD] (define-fun q2_model13_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model13 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_13 () Bool -               (or q1_model13_reject-                   q2_model13_reject-               ))-[GOOD] (assert uiFunRejector_model_13)-Looking for solution 14-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 (lambda ((x!1 Bool)) x!1)))-[SEND] (get-value (q2))-[RECV] ((q2 (store ((as const Array) true) false true false)))-[GOOD] (define-fun q1_model14 ((x!0 Bool)) Bool-          (ite (and (= x!0 true)) true-          false)-       )-[GOOD] (define-fun q1_model14_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model14 x!0))))-[GOOD] (define-fun q2_model14 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 false) (= x!1 true)) false-          true)-       )-[GOOD] (define-fun q2_model14_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model14 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_14 () Bool -               (or q1_model14_reject-                   q2_model14_reject-               ))-[GOOD] (assert uiFunRejector_model_14)-Looking for solution 15-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 ((as const Array) false)))-[SEND] (get-value (q2))-[RECV] ((q2 (store (store ((as const Array) true) false true false) true true false)))-[GOOD] (define-fun q1_model15 ((x!0 Bool)) Bool-          false-       )-[GOOD] (define-fun q1_model15_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model15 x!0))))-[GOOD] (define-fun q2_model15 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 true) (= x!1 true)) false-          (ite (and (= x!0 false) (= x!1 true)) false-          true))-       )-[GOOD] (define-fun q2_model15_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model15 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_15 () Bool -               (or q1_model15_reject-                   q2_model15_reject-               ))-[GOOD] (assert uiFunRejector_model_15)-Looking for solution 16-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 ((as const Array) false)))-[SEND] (get-value (q2))-[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and (not x!2) (not x!1)))))-[SEND] (get-value ((q2 false false)))-[RECV] (((q2 false false) true))-[SEND] (get-value ((q2 false true)))-[RECV] (((q2 false true) false))-[SEND] (get-value ((q2 true false)))-[RECV] (((q2 true false) false))-[SEND] (get-value ((q2 true true)))-[RECV] (((q2 true true) false))-[GOOD] (define-fun q1_model16 ((x!0 Bool)) Bool-          false-       )-[GOOD] (define-fun q1_model16_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model16 x!0))))-[GOOD] (define-fun q2_model16 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 false) (= x!1 false)) true-          false)-       )-[GOOD] (define-fun q2_model16_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model16 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_16 () Bool -               (or q1_model16_reject-                   q2_model16_reject-               ))-[GOOD] (assert uiFunRejector_model_16)-Looking for solution 17-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 (lambda ((x!1 Bool)) (not x!1))))-[SEND] (get-value (q2))-[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and (not x!2) (not x!1)))))-[SEND] (get-value ((q2 false false)))-[RECV] (((q2 false false) true))-[SEND] (get-value ((q2 false true)))-[RECV] (((q2 false true) false))-[SEND] (get-value ((q2 true false)))-[RECV] (((q2 true false) false))-[SEND] (get-value ((q2 true true)))-[RECV] (((q2 true true) false))-[GOOD] (define-fun q1_model17 ((x!0 Bool)) Bool-          (ite (and (= x!0 true)) false-          true)-       )-[GOOD] (define-fun q1_model17_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model17 x!0))))-[GOOD] (define-fun q2_model17 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 false) (= x!1 false)) true-          false)-       )-[GOOD] (define-fun q2_model17_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model17 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_17 () Bool -               (or q1_model17_reject-                   q2_model17_reject-               ))-[GOOD] (assert uiFunRejector_model_17)-Looking for solution 18-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 (lambda ((x!1 Bool)) (not x!1))))-[SEND] (get-value (q2))-[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool))-         (or (and (not x!2) (not x!1)) (and x!2 (not x!1))))))-[SEND] (get-value ((q2 false false)))-[RECV] (((q2 false false) true))-[SEND] (get-value ((q2 false true)))-[RECV] (((q2 false true) false))-[SEND] (get-value ((q2 true false)))-[RECV] (((q2 true false) true))-[SEND] (get-value ((q2 true true)))-[RECV] (((q2 true true) false))-[GOOD] (define-fun q1_model18 ((x!0 Bool)) Bool-          (ite (and (= x!0 true)) false-          true)-       )-[GOOD] (define-fun q1_model18_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model18 x!0))))-[GOOD] (define-fun q2_model18 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 false) (= x!1 false)) true-          (ite (and (= x!0 true) (= x!1 false)) true-          false))-       )-[GOOD] (define-fun q2_model18_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model18 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_18 () Bool -               (or q1_model18_reject-                   q2_model18_reject-               ))-[GOOD] (assert uiFunRejector_model_18)-Looking for solution 19-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 ((as const Array) true)))-[SEND] (get-value (q2))-[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool))-         (or (and (not x!2) (not x!1)) (and x!2 (not x!1))))))-[SEND] (get-value ((q2 false false)))-[RECV] (((q2 false false) true))-[SEND] (get-value ((q2 false true)))-[RECV] (((q2 false true) false))-[SEND] (get-value ((q2 true false)))-[RECV] (((q2 true false) true))-[SEND] (get-value ((q2 true true)))-[RECV] (((q2 true true) false))-[GOOD] (define-fun q1_model19 ((x!0 Bool)) Bool-          true-       )-[GOOD] (define-fun q1_model19_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model19 x!0))))-[GOOD] (define-fun q2_model19 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 false) (= x!1 false)) true-          (ite (and (= x!0 true) (= x!1 false)) true-          false))-       )-[GOOD] (define-fun q2_model19_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model19 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_19 () Bool -               (or q1_model19_reject-                   q2_model19_reject-               ))-[GOOD] (assert uiFunRejector_model_19)-Looking for solution 20-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 ((as const Array) true)))-[SEND] (get-value (q2))-[RECV] ((q2 (store ((as const Array) true) true true false)))-[GOOD] (define-fun q1_model20 ((x!0 Bool)) Bool-          true-       )-[GOOD] (define-fun q1_model20_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model20 x!0))))-[GOOD] (define-fun q2_model20 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 true) (= x!1 true)) false-          true)-       )-[GOOD] (define-fun q2_model20_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model20 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_20 () Bool -               (or q1_model20_reject-                   q2_model20_reject-               ))-[GOOD] (assert uiFunRejector_model_20)-Looking for solution 21-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 (store ((as const Array) true) true false)))-[SEND] (get-value (q2))-[RECV] ((q2 (store ((as const Array) true) true true false)))-[GOOD] (define-fun q1_model21 ((x!0 Bool)) Bool-          (ite (and (= x!0 true)) false-          true)-       )-[GOOD] (define-fun q1_model21_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model21 x!0))))-[GOOD] (define-fun q2_model21 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 true) (= x!1 true)) false-          true)-       )-[GOOD] (define-fun q2_model21_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model21 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_21 () Bool -               (or q1_model21_reject-                   q2_model21_reject-               ))-[GOOD] (assert uiFunRejector_model_21)-Looking for solution 22-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 (store ((as const Array) true) true false)))-[SEND] (get-value (q2))-[RECV] ((q2 ((as const Array) true)))-[GOOD] (define-fun q1_model22 ((x!0 Bool)) Bool-          (ite (and (= x!0 true)) false-          true)-       )-[GOOD] (define-fun q1_model22_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model22 x!0))))-[GOOD] (define-fun q2_model22 ((x!0 Bool) (x!1 Bool)) Bool-          true-       )-[GOOD] (define-fun q2_model22_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model22 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_22 () Bool -               (or q1_model22_reject-                   q2_model22_reject-               ))-[GOOD] (assert uiFunRejector_model_22)-Looking for solution 23-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 ((as const Array) true)))-[SEND] (get-value (q2))-[RECV] ((q2 ((as const Array) true)))-[GOOD] (define-fun q1_model23 ((x!0 Bool)) Bool-          true-       )-[GOOD] (define-fun q1_model23_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model23 x!0))))-[GOOD] (define-fun q2_model23 ((x!0 Bool) (x!1 Bool)) Bool-          true-       )-[GOOD] (define-fun q2_model23_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model23 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_23 () Bool -               (or q1_model23_reject-                   q2_model23_reject-               ))-[GOOD] (assert uiFunRejector_model_23)-Looking for solution 24-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 (lambda ((x!1 Bool)) x!1)))-[SEND] (get-value (q2))-[RECV] ((q2 (store ((as const Array) true) true true false)))-[GOOD] (define-fun q1_model24 ((x!0 Bool)) Bool-          (ite (and (= x!0 true)) true-          false)-       )-[GOOD] (define-fun q1_model24_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model24 x!0))))-[GOOD] (define-fun q2_model24 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 true) (= x!1 true)) false-          true)-       )-[GOOD] (define-fun q2_model24_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model24 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_24 () Bool -               (or q1_model24_reject-                   q2_model24_reject-               ))-[GOOD] (assert uiFunRejector_model_24)-Looking for solution 25-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 ((as const Array) false)))-[SEND] (get-value (q2))-[RECV] ((q2 (store ((as const Array) true) true true false)))-[GOOD] (define-fun q1_model25 ((x!0 Bool)) Bool-          false-       )-[GOOD] (define-fun q1_model25_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model25 x!0))))-[GOOD] (define-fun q2_model25 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 true) (= x!1 true)) false-          true)-       )-[GOOD] (define-fun q2_model25_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model25 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_25 () Bool -               (or q1_model25_reject-                   q2_model25_reject-               ))-[GOOD] (assert uiFunRejector_model_25)-Looking for solution 26-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 (lambda ((x!1 Bool)) x!1)))-[SEND] (get-value (q2))-[RECV] ((q2 (store (store ((as const Array) true) true true false) false true false)))-[GOOD] (define-fun q1_model26 ((x!0 Bool)) Bool-          (ite (and (= x!0 true)) true-          false)-       )-[GOOD] (define-fun q1_model26_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model26 x!0))))-[GOOD] (define-fun q2_model26 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 false) (= x!1 true)) false-          (ite (and (= x!0 true) (= x!1 true)) false-          true))-       )-[GOOD] (define-fun q2_model26_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model26 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_26 () Bool -               (or q1_model26_reject-                   q2_model26_reject-               ))-[GOOD] (assert uiFunRejector_model_26)-Looking for solution 27-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 (lambda ((x!1 Bool)) x!1)))-[SEND] (get-value (q2))-[RECV] ((q2 ((as const Array) false)))-[GOOD] (define-fun q1_model27 ((x!0 Bool)) Bool-          (ite (and (= x!0 true)) true-          false)-       )-[GOOD] (define-fun q1_model27_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model27 x!0))))-[GOOD] (define-fun q2_model27 ((x!0 Bool) (x!1 Bool)) Bool-          false-       )-[GOOD] (define-fun q2_model27_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model27 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_27 () Bool -               (or q1_model27_reject-                   q2_model27_reject-               ))-[GOOD] (assert uiFunRejector_model_27)-Looking for solution 28-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 (lambda ((x!1 Bool)) x!1)))-[SEND] (get-value (q2))-[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and x!2 (not x!1)))))-[SEND] (get-value ((q2 false false)))-[RECV] (((q2 false false) false))-[SEND] (get-value ((q2 false true)))-[RECV] (((q2 false true) false))-[SEND] (get-value ((q2 true false)))-[RECV] (((q2 true false) true))-[SEND] (get-value ((q2 true true)))-[RECV] (((q2 true true) false))-[GOOD] (define-fun q1_model28 ((x!0 Bool)) Bool-          (ite (and (= x!0 true)) true-          false)-       )-[GOOD] (define-fun q1_model28_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model28 x!0))))-[GOOD] (define-fun q2_model28 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 true) (= x!1 false)) true-          false)-       )-[GOOD] (define-fun q2_model28_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model28 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_28 () Bool -               (or q1_model28_reject-                   q2_model28_reject-               ))-[GOOD] (assert uiFunRejector_model_28)-Looking for solution 29-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 (lambda ((x!1 Bool)) x!1)))-[SEND] (get-value (q2))-[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and (not x!2) x!1))))-[SEND] (get-value ((q2 false false)))-[RECV] (((q2 false false) false))-[SEND] (get-value ((q2 false true)))-[RECV] (((q2 false true) true))-[SEND] (get-value ((q2 true false)))-[RECV] (((q2 true false) false))-[SEND] (get-value ((q2 true true)))-[RECV] (((q2 true true) false))-[GOOD] (define-fun q1_model29 ((x!0 Bool)) Bool-          (ite (and (= x!0 true)) true-          false)-       )-[GOOD] (define-fun q1_model29_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model29 x!0))))-[GOOD] (define-fun q2_model29 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 false) (= x!1 true)) true-          false)-       )-[GOOD] (define-fun q2_model29_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model29 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_29 () Bool -               (or q1_model29_reject-                   q2_model29_reject-               ))-[GOOD] (assert uiFunRejector_model_29)-Looking for solution 30-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 (lambda ((x!1 Bool)) x!1)))-[SEND] (get-value (q2))-[RECV] ((q2 (store ((as const Array) true) false false false)))-[GOOD] (define-fun q1_model30 ((x!0 Bool)) Bool-          (ite (and (= x!0 true)) true-          false)-       )-[GOOD] (define-fun q1_model30_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model30 x!0))))-[GOOD] (define-fun q2_model30 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 false) (= x!1 false)) false-          true)-       )-[GOOD] (define-fun q2_model30_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model30 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_30 () Bool -               (or q1_model30_reject-                   q2_model30_reject-               ))-[GOOD] (assert uiFunRejector_model_30)-Looking for solution 31-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 (lambda ((x!1 Bool)) x!1)))-[SEND] (get-value (q2))-[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and x!2 x!1))))-[SEND] (get-value ((q2 false false)))-[RECV] (((q2 false false) false))-[SEND] (get-value ((q2 false true)))-[RECV] (((q2 false true) false))-[SEND] (get-value ((q2 true false)))-[RECV] (((q2 true false) false))-[SEND] (get-value ((q2 true true)))-[RECV] (((q2 true true) true))-[GOOD] (define-fun q1_model31 ((x!0 Bool)) Bool-          (ite (and (= x!0 true)) true-          false)-       )-[GOOD] (define-fun q1_model31_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model31 x!0))))-[GOOD] (define-fun q2_model31 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 true) (= x!1 true)) true-          false)-       )-[GOOD] (define-fun q2_model31_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model31 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_31 () Bool -               (or q1_model31_reject-                   q2_model31_reject-               ))-[GOOD] (assert uiFunRejector_model_31)-Looking for solution 32-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 ((as const Array) false)))-[SEND] (get-value (q2))-[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and x!2 (not x!1)))))-[SEND] (get-value ((q2 false false)))-[RECV] (((q2 false false) false))-[SEND] (get-value ((q2 false true)))-[RECV] (((q2 false true) false))-[SEND] (get-value ((q2 true false)))-[RECV] (((q2 true false) true))-[SEND] (get-value ((q2 true true)))-[RECV] (((q2 true true) false))-[GOOD] (define-fun q1_model32 ((x!0 Bool)) Bool-          false-       )-[GOOD] (define-fun q1_model32_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model32 x!0))))-[GOOD] (define-fun q2_model32 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 true) (= x!1 false)) true-          false)-       )-[GOOD] (define-fun q2_model32_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model32 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_32 () Bool -               (or q1_model32_reject-                   q2_model32_reject-               ))-[GOOD] (assert uiFunRejector_model_32)-Looking for solution 33-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 ((as const Array) false)))-[SEND] (get-value (q2))-[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and (not x!2) x!1))))-[SEND] (get-value ((q2 false false)))-[RECV] (((q2 false false) false))-[SEND] (get-value ((q2 false true)))-[RECV] (((q2 false true) true))-[SEND] (get-value ((q2 true false)))-[RECV] (((q2 true false) false))-[SEND] (get-value ((q2 true true)))-[RECV] (((q2 true true) false))-[GOOD] (define-fun q1_model33 ((x!0 Bool)) Bool-          false-       )-[GOOD] (define-fun q1_model33_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model33 x!0))))-[GOOD] (define-fun q2_model33 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 false) (= x!1 true)) true-          false)-       )-[GOOD] (define-fun q2_model33_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model33 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_33 () Bool -               (or q1_model33_reject-                   q2_model33_reject-               ))-[GOOD] (assert uiFunRejector_model_33)-Looking for solution 34-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 ((as const Array) false)))-[SEND] (get-value (q2))-[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (or (and x!2 x!1) (and x!2 (not x!1))))))-[SEND] (get-value ((q2 false false)))-[RECV] (((q2 false false) false))-[SEND] (get-value ((q2 false true)))-[RECV] (((q2 false true) false))-[SEND] (get-value ((q2 true false)))-[RECV] (((q2 true false) true))-[SEND] (get-value ((q2 true true)))-[RECV] (((q2 true true) true))-[GOOD] (define-fun q1_model34 ((x!0 Bool)) Bool-          false-       )-[GOOD] (define-fun q1_model34_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model34 x!0))))-[GOOD] (define-fun q2_model34 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 true) (= x!1 false)) true-          (ite (and (= x!0 true) (= x!1 true)) true-          false))-       )-[GOOD] (define-fun q2_model34_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model34 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_34 () Bool -               (or q1_model34_reject-                   q2_model34_reject-               ))-[GOOD] (assert uiFunRejector_model_34)-Looking for solution 35-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 ((as const Array) false)))-[SEND] (get-value (q2))-[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (or (and x!2 x!1) (and (not x!2) x!1)))))-[SEND] (get-value ((q2 false false)))-[RECV] (((q2 false false) false))-[SEND] (get-value ((q2 false true)))-[RECV] (((q2 false true) true))-[SEND] (get-value ((q2 true false)))-[RECV] (((q2 true false) false))-[SEND] (get-value ((q2 true true)))-[RECV] (((q2 true true) true))-[GOOD] (define-fun q1_model35 ((x!0 Bool)) Bool-          false-       )-[GOOD] (define-fun q1_model35_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model35 x!0))))-[GOOD] (define-fun q2_model35 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 false) (= x!1 true)) true-          (ite (and (= x!0 true) (= x!1 true)) true-          false))-       )-[GOOD] (define-fun q2_model35_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model35 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_35 () Bool -               (or q1_model35_reject-                   q2_model35_reject-               ))-[GOOD] (assert uiFunRejector_model_35)-Looking for solution 36-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 (lambda ((x!1 Bool)) x!1)))-[SEND] (get-value (q2))-[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (or (and x!2 x!1) (and (not x!2) x!1)))))-[SEND] (get-value ((q2 false false)))-[RECV] (((q2 false false) false))-[SEND] (get-value ((q2 false true)))-[RECV] (((q2 false true) true))-[SEND] (get-value ((q2 true false)))-[RECV] (((q2 true false) false))-[SEND] (get-value ((q2 true true)))-[RECV] (((q2 true true) true))-[GOOD] (define-fun q1_model36 ((x!0 Bool)) Bool-          (ite (and (= x!0 true)) true-          false)-       )-[GOOD] (define-fun q1_model36_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model36 x!0))))-[GOOD] (define-fun q2_model36 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 false) (= x!1 true)) true-          (ite (and (= x!0 true) (= x!1 true)) true-          false))-       )-[GOOD] (define-fun q2_model36_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model36 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_36 () Bool -               (or q1_model36_reject-                   q2_model36_reject-               ))-[GOOD] (assert uiFunRejector_model_36)-Looking for solution 37-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 ((as const Array) false)))-[SEND] (get-value (q2))-[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and x!2 x!1))))-[SEND] (get-value ((q2 false false)))-[RECV] (((q2 false false) false))-[SEND] (get-value ((q2 false true)))-[RECV] (((q2 false true) false))-[SEND] (get-value ((q2 true false)))-[RECV] (((q2 true false) false))-[SEND] (get-value ((q2 true true)))-[RECV] (((q2 true true) true))-[GOOD] (define-fun q1_model37 ((x!0 Bool)) Bool-          false-       )-[GOOD] (define-fun q1_model37_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model37 x!0))))-[GOOD] (define-fun q2_model37 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 true) (= x!1 true)) true-          false)-       )-[GOOD] (define-fun q2_model37_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model37 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_37 () Bool -               (or q1_model37_reject-                   q2_model37_reject-               ))-[GOOD] (assert uiFunRejector_model_37)-Looking for solution 38-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 ((as const Array) false)))-[SEND] (get-value (q2))-[RECV] ((q2 (store ((as const Array) true) false false false)))-[GOOD] (define-fun q1_model38 ((x!0 Bool)) Bool-          false-       )-[GOOD] (define-fun q1_model38_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model38 x!0))))-[GOOD] (define-fun q2_model38 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 false) (= x!1 false)) false-          true)-       )-[GOOD] (define-fun q2_model38_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model38 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_38 () Bool -               (or q1_model38_reject-                   q2_model38_reject-               ))-[GOOD] (assert uiFunRejector_model_38)-Looking for solution 39-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 (lambda ((x!1 Bool)) (not x!1))))-[SEND] (get-value (q2))-[RECV] ((q2 (store ((as const Array) true) false false false)))-[GOOD] (define-fun q1_model39 ((x!0 Bool)) Bool-          (ite (and (= x!0 true)) false-          true)-       )-[GOOD] (define-fun q1_model39_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model39 x!0))))-[GOOD] (define-fun q2_model39 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 false) (= x!1 false)) false-          true)-       )-[GOOD] (define-fun q2_model39_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model39 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_39 () Bool -               (or q1_model39_reject-                   q2_model39_reject-               ))-[GOOD] (assert uiFunRejector_model_39)-Looking for solution 40-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 (lambda ((x!1 Bool)) (not x!1))))-[SEND] (get-value (q2))-[RECV] ((q2 (store (store ((as const Array) true) false false false) true true false)))-[GOOD] (define-fun q1_model40 ((x!0 Bool)) Bool-          (ite (and (= x!0 true)) false-          true)-       )-[GOOD] (define-fun q1_model40_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model40 x!0))))-[GOOD] (define-fun q2_model40 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 true) (= x!1 true)) false-          (ite (and (= x!0 false) (= x!1 false)) false-          true))-       )-[GOOD] (define-fun q2_model40_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model40 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_40 () Bool -               (or q1_model40_reject-                   q2_model40_reject-               ))-[GOOD] (assert uiFunRejector_model_40)-Looking for solution 41-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 ((as const Array) true)))-[SEND] (get-value (q2))-[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (or (and (not x!2) x!1) (and x!2 (not x!1))))))-[SEND] (get-value ((q2 false false)))-[RECV] (((q2 false false) false))-[SEND] (get-value ((q2 false true)))-[RECV] (((q2 false true) true))-[SEND] (get-value ((q2 true false)))-[RECV] (((q2 true false) true))-[SEND] (get-value ((q2 true true)))-[RECV] (((q2 true true) false))-[GOOD] (define-fun q1_model41 ((x!0 Bool)) Bool-          true-       )-[GOOD] (define-fun q1_model41_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model41 x!0))))-[GOOD] (define-fun q2_model41 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 false) (= x!1 true)) true-          (ite (and (= x!0 true) (= x!1 false)) true-          false))-       )-[GOOD] (define-fun q2_model41_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model41 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_41 () Bool -               (or q1_model41_reject-                   q2_model41_reject-               ))-[GOOD] (assert uiFunRejector_model_41)-Looking for solution 42-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 ((as const Array) true)))-[SEND] (get-value (q2))-[RECV] ((q2 (store ((as const Array) true) false false false)))-[GOOD] (define-fun q1_model42 ((x!0 Bool)) Bool-          true-       )-[GOOD] (define-fun q1_model42_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model42 x!0))))-[GOOD] (define-fun q2_model42 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 false) (= x!1 false)) false-          true)-       )-[GOOD] (define-fun q2_model42_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model42 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_42 () Bool -               (or q1_model42_reject-                   q2_model42_reject-               ))-[GOOD] (assert uiFunRejector_model_42)-Looking for solution 43-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 ((as const Array) true)))-[SEND] (get-value (q2))-[RECV] ((q2 (store (store ((as const Array) true) false false false) false true false)))-[GOOD] (define-fun q1_model43 ((x!0 Bool)) Bool-          true-       )-[GOOD] (define-fun q1_model43_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model43 x!0))))-[GOOD] (define-fun q2_model43 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 false) (= x!1 true)) false-          (ite (and (= x!0 false) (= x!1 false)) false-          true))-       )-[GOOD] (define-fun q2_model43_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model43 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_43 () Bool -               (or q1_model43_reject-                   q2_model43_reject-               ))-[GOOD] (assert uiFunRejector_model_43)-Looking for solution 44-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 ((as const Array) true)))-[SEND] (get-value (q2))-[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and x!2 (not x!1)))))-[SEND] (get-value ((q2 false false)))-[RECV] (((q2 false false) false))-[SEND] (get-value ((q2 false true)))-[RECV] (((q2 false true) false))-[SEND] (get-value ((q2 true false)))-[RECV] (((q2 true false) true))-[SEND] (get-value ((q2 true true)))-[RECV] (((q2 true true) false))-[GOOD] (define-fun q1_model44 ((x!0 Bool)) Bool-          true-       )-[GOOD] (define-fun q1_model44_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model44 x!0))))-[GOOD] (define-fun q2_model44 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 true) (= x!1 false)) true-          false)-       )-[GOOD] (define-fun q2_model44_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model44 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_44 () Bool -               (or q1_model44_reject-                   q2_model44_reject-               ))-[GOOD] (assert uiFunRejector_model_44)-Looking for solution 45-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 (store ((as const Array) true) true false)))-[SEND] (get-value (q2))-[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and x!2 (not x!1)))))-[SEND] (get-value ((q2 false false)))-[RECV] (((q2 false false) false))-[SEND] (get-value ((q2 false true)))-[RECV] (((q2 false true) false))-[SEND] (get-value ((q2 true false)))-[RECV] (((q2 true false) true))-[SEND] (get-value ((q2 true true)))-[RECV] (((q2 true true) false))-[GOOD] (define-fun q1_model45 ((x!0 Bool)) Bool-          (ite (and (= x!0 true)) false-          true)-       )-[GOOD] (define-fun q1_model45_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model45 x!0))))-[GOOD] (define-fun q2_model45 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 true) (= x!1 false)) true-          false)-       )-[GOOD] (define-fun q2_model45_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model45 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_45 () Bool -               (or q1_model45_reject-                   q2_model45_reject-               ))-[GOOD] (assert uiFunRejector_model_45)-Looking for solution 46-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 (store ((as const Array) true) true false)))-[SEND] (get-value (q2))-[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (or (and x!2 x!1) (and x!2 (not x!1))))))-[SEND] (get-value ((q2 false false)))-[RECV] (((q2 false false) false))-[SEND] (get-value ((q2 false true)))-[RECV] (((q2 false true) false))-[SEND] (get-value ((q2 true false)))-[RECV] (((q2 true false) true))-[SEND] (get-value ((q2 true true)))-[RECV] (((q2 true true) true))-[GOOD] (define-fun q1_model46 ((x!0 Bool)) Bool-          (ite (and (= x!0 true)) false-          true)-       )-[GOOD] (define-fun q1_model46_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model46 x!0))))-[GOOD] (define-fun q2_model46 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 true) (= x!1 false)) true-          (ite (and (= x!0 true) (= x!1 true)) true-          false))-       )-[GOOD] (define-fun q2_model46_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model46 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_46 () Bool -               (or q1_model46_reject-                   q2_model46_reject-               ))-[GOOD] (assert uiFunRejector_model_46)-Looking for solution 47-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 (store ((as const Array) true) true false)))-[SEND] (get-value (q2))-[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (or (and x!2 x!1) (and (not x!2) x!1)))))-[SEND] (get-value ((q2 false false)))-[RECV] (((q2 false false) false))-[SEND] (get-value ((q2 false true)))-[RECV] (((q2 false true) true))-[SEND] (get-value ((q2 true false)))-[RECV] (((q2 true false) false))-[SEND] (get-value ((q2 true true)))-[RECV] (((q2 true true) true))-[GOOD] (define-fun q1_model47 ((x!0 Bool)) Bool-          (ite (and (= x!0 true)) false-          true)-       )-[GOOD] (define-fun q1_model47_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model47 x!0))))-[GOOD] (define-fun q2_model47 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 false) (= x!1 true)) true-          (ite (and (= x!0 true) (= x!1 true)) true-          false))-       )-[GOOD] (define-fun q2_model47_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model47 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_47 () Bool -               (or q1_model47_reject-                   q2_model47_reject-               ))-[GOOD] (assert uiFunRejector_model_47)-Looking for solution 48-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 ((as const Array) true)))-[SEND] (get-value (q2))-[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (or (and x!2 x!1) (and (not x!2) x!1)))))-[SEND] (get-value ((q2 false false)))-[RECV] (((q2 false false) false))-[SEND] (get-value ((q2 false true)))-[RECV] (((q2 false true) true))-[SEND] (get-value ((q2 true false)))-[RECV] (((q2 true false) false))-[SEND] (get-value ((q2 true true)))-[RECV] (((q2 true true) true))-[GOOD] (define-fun q1_model48 ((x!0 Bool)) Bool-          true-       )-[GOOD] (define-fun q1_model48_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model48 x!0))))-[GOOD] (define-fun q2_model48 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 false) (= x!1 true)) true-          (ite (and (= x!0 true) (= x!1 true)) true-          false))-       )-[GOOD] (define-fun q2_model48_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model48 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_48 () Bool -               (or q1_model48_reject-                   q2_model48_reject-               ))-[GOOD] (assert uiFunRejector_model_48)-Looking for solution 49-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 ((as const Array) true)))-[SEND] (get-value (q2))-[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and x!2 x!1))))-[SEND] (get-value ((q2 false false)))-[RECV] (((q2 false false) false))-[SEND] (get-value ((q2 false true)))-[RECV] (((q2 false true) false))-[SEND] (get-value ((q2 true false)))-[RECV] (((q2 true false) false))-[SEND] (get-value ((q2 true true)))-[RECV] (((q2 true true) true))-[GOOD] (define-fun q1_model49 ((x!0 Bool)) Bool-          true-       )-[GOOD] (define-fun q1_model49_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model49 x!0))))-[GOOD] (define-fun q2_model49 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 true) (= x!1 true)) true-          false)-       )-[GOOD] (define-fun q2_model49_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model49 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_49 () Bool -               (or q1_model49_reject-                   q2_model49_reject-               ))-[GOOD] (assert uiFunRejector_model_49)-Looking for solution 50-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 (lambda ((x!1 Bool)) (not x!1))))-[SEND] (get-value (q2))-[RECV] ((q2 ((as const Array) false)))-[GOOD] (define-fun q1_model50 ((x!0 Bool)) Bool-          (ite (and (= x!0 true)) false-          true)-       )-[GOOD] (define-fun q1_model50_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model50 x!0))))-[GOOD] (define-fun q2_model50 ((x!0 Bool) (x!1 Bool)) Bool-          false-       )-[GOOD] (define-fun q2_model50_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model50 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_50 () Bool -               (or q1_model50_reject-                   q2_model50_reject-               ))-[GOOD] (assert uiFunRejector_model_50)-Looking for solution 51-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 ((as const Array) true)))-[SEND] (get-value (q2))-[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and (not x!2) (not x!1)))))-[SEND] (get-value ((q2 false false)))-[RECV] (((q2 false false) true))-[SEND] (get-value ((q2 false true)))-[RECV] (((q2 false true) false))-[SEND] (get-value ((q2 true false)))-[RECV] (((q2 true false) false))-[SEND] (get-value ((q2 true true)))-[RECV] (((q2 true true) false))-[GOOD] (define-fun q1_model51 ((x!0 Bool)) Bool-          true-       )-[GOOD] (define-fun q1_model51_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model51 x!0))))-[GOOD] (define-fun q2_model51 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 false) (= x!1 false)) true-          false)-       )-[GOOD] (define-fun q2_model51_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model51 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_51 () Bool -               (or q1_model51_reject-                   q2_model51_reject-               ))-[GOOD] (assert uiFunRejector_model_51)-Looking for solution 52-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 ((as const Array) true)))-[SEND] (get-value (q2))-[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool))-         (or (and (not x!2) (not x!1)) (and (not x!2) x!1)))))-[SEND] (get-value ((q2 false false)))-[RECV] (((q2 false false) true))-[SEND] (get-value ((q2 false true)))-[RECV] (((q2 false true) true))-[SEND] (get-value ((q2 true false)))-[RECV] (((q2 true false) false))-[SEND] (get-value ((q2 true true)))-[RECV] (((q2 true true) false))-[GOOD] (define-fun q1_model52 ((x!0 Bool)) Bool-          true-       )-[GOOD] (define-fun q1_model52_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model52 x!0))))-[GOOD] (define-fun q2_model52 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 false) (= x!1 false)) true-          (ite (and (= x!0 false) (= x!1 true)) true-          false))-       )-[GOOD] (define-fun q2_model52_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model52 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_52 () Bool -               (or q1_model52_reject-                   q2_model52_reject-               ))-[GOOD] (assert uiFunRejector_model_52)-Looking for solution 53-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 (lambda ((x!1 Bool)) x!1)))-[SEND] (get-value (q2))-[RECV] ((q2 (store (store ((as const Array) true) true true false) false false false)))-[GOOD] (define-fun q1_model53 ((x!0 Bool)) Bool-          (ite (and (= x!0 true)) true-          false)-       )-[GOOD] (define-fun q1_model53_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model53 x!0))))-[GOOD] (define-fun q2_model53 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 false) (= x!1 false)) false-          (ite (and (= x!0 true) (= x!1 true)) false-          true))-       )-[GOOD] (define-fun q2_model53_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model53 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_53 () Bool -               (or q1_model53_reject-                   q2_model53_reject-               ))-[GOOD] (assert uiFunRejector_model_53)-Looking for solution 54-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 ((as const Array) false)))-[SEND] (get-value (q2))-[RECV] ((q2 (store (store ((as const Array) true) true true false) false false false)))-[GOOD] (define-fun q1_model54 ((x!0 Bool)) Bool-          false-       )-[GOOD] (define-fun q1_model54_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model54 x!0))))-[GOOD] (define-fun q2_model54 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 false) (= x!1 false)) false-          (ite (and (= x!0 true) (= x!1 true)) false-          true))-       )-[GOOD] (define-fun q2_model54_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model54 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_54 () Bool -               (or q1_model54_reject-                   q2_model54_reject-               ))-[GOOD] (assert uiFunRejector_model_54)-Looking for solution 55-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 ((as const Array) true)))-[SEND] (get-value (q2))-[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and (not x!2) x!1))))-[SEND] (get-value ((q2 false false)))-[RECV] (((q2 false false) false))-[SEND] (get-value ((q2 false true)))-[RECV] (((q2 false true) true))-[SEND] (get-value ((q2 true false)))-[RECV] (((q2 true false) false))-[SEND] (get-value ((q2 true true)))-[RECV] (((q2 true true) false))-[GOOD] (define-fun q1_model55 ((x!0 Bool)) Bool-          true-       )-[GOOD] (define-fun q1_model55_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model55 x!0))))-[GOOD] (define-fun q2_model55 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 false) (= x!1 true)) true-          false)-       )-[GOOD] (define-fun q2_model55_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model55 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_55 () Bool -               (or q1_model55_reject-                   q2_model55_reject-               ))-[GOOD] (assert uiFunRejector_model_55)-Looking for solution 56-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 (lambda ((x!1 Bool)) x!1)))-[SEND] (get-value (q2))-[RECV] ((q2 (store (store ((as const Array) true) false false false) false true false)))-[GOOD] (define-fun q1_model56 ((x!0 Bool)) Bool-          (ite (and (= x!0 true)) true-          false)-       )-[GOOD] (define-fun q1_model56_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model56 x!0))))-[GOOD] (define-fun q2_model56 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 false) (= x!1 true)) false-          (ite (and (= x!0 false) (= x!1 false)) false-          true))-       )-[GOOD] (define-fun q2_model56_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model56 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_56 () Bool -               (or q1_model56_reject-                   q2_model56_reject-               ))-[GOOD] (assert uiFunRejector_model_56)-Looking for solution 57-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 (store ((as const Array) true) true false)))-[SEND] (get-value (q2))-[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and x!2 x!1))))-[SEND] (get-value ((q2 false false)))-[RECV] (((q2 false false) false))-[SEND] (get-value ((q2 false true)))-[RECV] (((q2 false true) false))-[SEND] (get-value ((q2 true false)))-[RECV] (((q2 true false) false))-[SEND] (get-value ((q2 true true)))-[RECV] (((q2 true true) true))-[GOOD] (define-fun q1_model57 ((x!0 Bool)) Bool-          (ite (and (= x!0 true)) false-          true)-       )-[GOOD] (define-fun q1_model57_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model57 x!0))))-[GOOD] (define-fun q2_model57 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 true) (= x!1 true)) true-          false)-       )-[GOOD] (define-fun q2_model57_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model57 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_57 () Bool -               (or q1_model57_reject-                   q2_model57_reject-               ))-[GOOD] (assert uiFunRejector_model_57)-Looking for solution 58-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 (store ((as const Array) true) true false)))-[SEND] (get-value (q2))-[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and (not x!2) x!1))))-[SEND] (get-value ((q2 false false)))-[RECV] (((q2 false false) false))-[SEND] (get-value ((q2 false true)))-[RECV] (((q2 false true) true))-[SEND] (get-value ((q2 true false)))-[RECV] (((q2 true false) false))-[SEND] (get-value ((q2 true true)))-[RECV] (((q2 true true) false))-[GOOD] (define-fun q1_model58 ((x!0 Bool)) Bool-          (ite (and (= x!0 true)) false-          true)-       )-[GOOD] (define-fun q1_model58_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model58 x!0))))-[GOOD] (define-fun q2_model58 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 false) (= x!1 true)) true-          false)-       )-[GOOD] (define-fun q2_model58_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model58 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_58 () Bool -               (or q1_model58_reject-                   q2_model58_reject-               ))-[GOOD] (assert uiFunRejector_model_58)-Looking for solution 59-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 (lambda ((x!1 Bool)) x!1)))-[SEND] (get-value (q2))-[RECV] ((q2 ((as const Array) true)))-[GOOD] (define-fun q1_model59 ((x!0 Bool)) Bool-          (ite (and (= x!0 true)) true-          false)-       )-[GOOD] (define-fun q1_model59_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model59 x!0))))-[GOOD] (define-fun q2_model59 ((x!0 Bool) (x!1 Bool)) Bool-          true-       )-[GOOD] (define-fun q2_model59_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model59 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_59 () Bool -               (or q1_model59_reject-                   q2_model59_reject-               ))-[GOOD] (assert uiFunRejector_model_59)-Looking for solution 60-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 ((as const Array) false)))-[SEND] (get-value (q2))-[RECV] ((q2 (store (store ((as const Array) true) true true false) true false false)))-[GOOD] (define-fun q1_model60 ((x!0 Bool)) Bool-          false-       )-[GOOD] (define-fun q1_model60_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model60 x!0))))-[GOOD] (define-fun q2_model60 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 true) (= x!1 false)) false-          (ite (and (= x!0 true) (= x!1 true)) false-          true))-       )-[GOOD] (define-fun q2_model60_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model60 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_60 () Bool -               (or q1_model60_reject-                   q2_model60_reject-               ))-[GOOD] (assert uiFunRejector_model_60)-Looking for solution 61-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 (lambda ((x!1 Bool)) x!1)))-[SEND] (get-value (q2))-[RECV] ((q2 (store (store ((as const Array) true) true true false) true false false)))-[GOOD] (define-fun q1_model61 ((x!0 Bool)) Bool-          (ite (and (= x!0 true)) true-          false)-       )-[GOOD] (define-fun q1_model61_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model61 x!0))))-[GOOD] (define-fun q2_model61 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 true) (= x!1 false)) false-          (ite (and (= x!0 true) (= x!1 true)) false-          true))-       )-[GOOD] (define-fun q2_model61_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model61 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_61 () Bool -               (or q1_model61_reject-                   q2_model61_reject-               ))-[GOOD] (assert uiFunRejector_model_61)-Looking for solution 62-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 (store ((as const Array) true) true false)))-[SEND] (get-value (q2))-[RECV] ((q2 (store (store ((as const Array) true) true true false) true false false)))-[GOOD] (define-fun q1_model62 ((x!0 Bool)) Bool-          (ite (and (= x!0 true)) false-          true)-       )-[GOOD] (define-fun q1_model62_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model62 x!0))))-[GOOD] (define-fun q2_model62 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 true) (= x!1 false)) false-          (ite (and (= x!0 true) (= x!1 true)) false-          true))-       )-[GOOD] (define-fun q2_model62_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model62 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_62 () Bool -               (or q1_model62_reject-                   q2_model62_reject-               ))-[GOOD] (assert uiFunRejector_model_62)-Looking for solution 63-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 (store ((as const Array) true) true false)))-[SEND] (get-value (q2))-[RECV] ((q2 (store ((as const Array) true) true false false)))-[GOOD] (define-fun q1_model63 ((x!0 Bool)) Bool-          (ite (and (= x!0 true)) false-          true)-       )-[GOOD] (define-fun q1_model63_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model63 x!0))))-[GOOD] (define-fun q2_model63 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 true) (= x!1 false)) false-          true)-       )-[GOOD] (define-fun q2_model63_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model63 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_63 () Bool -               (or q1_model63_reject-                   q2_model63_reject-               ))-[GOOD] (assert uiFunRejector_model_63)-Looking for solution 64-[SEND] (check-sat)-[RECV] sat-[SEND] (get-value (q1))-[RECV] ((q1 ((as const Array) true)))-[SEND] (get-value (q2))-[RECV] ((q2 (store ((as const Array) true) true false false)))-[GOOD] (define-fun q1_model64 ((x!0 Bool)) Bool-          true-       )-[GOOD] (define-fun q1_model64_reject () Bool-          (exists ((x!0 Bool))-                  (distinct (q1         x!0)-                            (q1_model64 x!0))))-[GOOD] (define-fun q2_model64 ((x!0 Bool) (x!1 Bool)) Bool-          (ite (and (= x!0 true) (= x!1 false)) false-          true)-       )-[GOOD] (define-fun q2_model64_reject () Bool-          (exists ((x!0 Bool) (x!1 Bool))-                  (distinct (q2         x!0 x!1)-                            (q2_model64 x!0 x!1))))-[GOOD] (define-fun uiFunRejector_model_64 () Bool -               (or q1_model64_reject-                   q2_model64_reject-               ))-[GOOD] (assert uiFunRejector_model_64)-Looking for solution 65-[SEND] (check-sat)-[RECV] unsat-*** Solver   : Z3-*** Exit code: ExitSuccess--RESULT: Solution #1:-  q1 :: Bool -> Bool-  q1 _ = False--  q2 :: Bool -> Bool -> Bool-  q2 _ _ = False-Solution #2:-  q1 :: Bool -> Bool-  q1 _ = True--  q2 :: Bool -> Bool -> Bool-  q2 _ _ = False-Solution #3:-  q1 :: Bool -> Bool-  q1 _ = False--  q2 :: Bool -> Bool -> Bool-  q2 _ _ = True-Solution #4:-  q1 :: Bool -> Bool-  q1 _ = False--  q2 :: Bool -> Bool -> Bool-  q2 True False = False-  q2 _    _     = True -Solution #5:-  q1 :: Bool -> Bool-  q1 True = True -  q1 _    = False--  q2 :: Bool -> Bool -> Bool-  q2 True False = False-  q2 _    _     = True -Solution #6:-  q1 :: Bool -> Bool-  q1 True = True -  q1 _    = False--  q2 :: Bool -> Bool -> Bool-  q2 False False = True -  q2 _     _     = False-Solution #7:-  q1 :: Bool -> Bool-  q1 True = True -  q1 _    = False--  q2 :: Bool -> Bool -> Bool-  q2 False False = True -  q2 True  True  = True -  q2 _     _     = False-Solution #8:-  q1 :: Bool -> Bool-  q1 _ = False--  q2 :: Bool -> Bool -> Bool-  q2 False False = True -  q2 True  True  = True -  q2 _     _     = False-Solution #9:-  q1 :: Bool -> Bool-  q1 True = False-  q1 _    = True --  q2 :: Bool -> Bool -> Bool-  q2 False False = True -  q2 True  True  = True -  q2 _     _     = False-Solution #10:-  q1 :: Bool -> Bool-  q1 _ = False--  q2 :: Bool -> Bool -> Bool-  q2 False True = False-  q2 _     _    = True -Solution #11:-  q1 :: Bool -> Bool-  q1 True = False-  q1 _    = True --  q2 :: Bool -> Bool -> Bool-  q2 False True = False-  q2 _     _    = True -Solution #12:-  q1 :: Bool -> Bool-  q1 _ = True--  q2 :: Bool -> Bool -> Bool-  q2 False True = False-  q2 _     _    = True -Solution #13:-  q1 :: Bool -> Bool-  q1 _ = True--  q2 :: Bool -> Bool -> Bool-  q2 True  False = False-  q2 False True  = False-  q2 _     _     = True -Solution #14:-  q1 :: Bool -> Bool-  q1 True = True -  q1 _    = False--  q2 :: Bool -> Bool -> Bool-  q2 False True = False-  q2 _     _    = True -Solution #15:-  q1 :: Bool -> Bool-  q1 _ = False--  q2 :: Bool -> Bool -> Bool-  q2 True  True = False-  q2 False True = False-  q2 _     _    = True -Solution #16:-  q1 :: Bool -> Bool-  q1 _ = False--  q2 :: Bool -> Bool -> Bool-  q2 False False = True -  q2 _     _     = False-Solution #17:-  q1 :: Bool -> Bool-  q1 True = False-  q1 _    = True --  q2 :: Bool -> Bool -> Bool-  q2 False False = True -  q2 _     _     = False-Solution #18:-  q1 :: Bool -> Bool-  q1 True = False-  q1 _    = True --  q2 :: Bool -> Bool -> Bool-  q2 False False = True -  q2 True  False = True -  q2 _     _     = False-Solution #19:-  q1 :: Bool -> Bool-  q1 _ = True--  q2 :: Bool -> Bool -> Bool-  q2 False False = True -  q2 True  False = True -  q2 _     _     = False-Solution #20:-  q1 :: Bool -> Bool-  q1 _ = True--  q2 :: Bool -> Bool -> Bool-  q2 True True = False-  q2 _    _    = True -Solution #21:-  q1 :: Bool -> Bool-  q1 True = False-  q1 _    = True --  q2 :: Bool -> Bool -> Bool-  q2 True True = False-  q2 _    _    = True -Solution #22:-  q1 :: Bool -> Bool-  q1 True = False-  q1 _    = True --  q2 :: Bool -> Bool -> Bool-  q2 _ _ = True-Solution #23:-  q1 :: Bool -> Bool-  q1 _ = True--  q2 :: Bool -> Bool -> Bool-  q2 _ _ = True-Solution #24:-  q1 :: Bool -> Bool-  q1 True = True -  q1 _    = False--  q2 :: Bool -> Bool -> Bool-  q2 True True = False-  q2 _    _    = True -Solution #25:-  q1 :: Bool -> Bool-  q1 _ = False--  q2 :: Bool -> Bool -> Bool-  q2 True True = False-  q2 _    _    = True -Solution #26:-  q1 :: Bool -> Bool-  q1 True = True -  q1 _    = False--  q2 :: Bool -> Bool -> Bool-  q2 False True = False-  q2 True  True = False-  q2 _     _    = True -Solution #27:-  q1 :: Bool -> Bool-  q1 True = True -  q1 _    = False--  q2 :: Bool -> Bool -> Bool-  q2 _ _ = False-Solution #28:-  q1 :: Bool -> Bool-  q1 True = True -  q1 _    = False--  q2 :: Bool -> Bool -> Bool-  q2 True False = True -  q2 _    _     = False-Solution #29:-  q1 :: Bool -> Bool-  q1 True = True -  q1 _    = False--  q2 :: Bool -> Bool -> Bool-  q2 False True = True -  q2 _     _    = False-Solution #30:-  q1 :: Bool -> Bool-  q1 True = True -  q1 _    = False--  q2 :: Bool -> Bool -> Bool-  q2 False False = False-  q2 _     _     = True -Solution #31:-  q1 :: Bool -> Bool-  q1 True = True -  q1 _    = False--  q2 :: Bool -> Bool -> Bool-  q2 True True = True -  q2 _    _    = False-Solution #32:-  q1 :: Bool -> Bool-  q1 _ = False--  q2 :: Bool -> Bool -> Bool-  q2 True False = True -  q2 _    _     = False-Solution #33:-  q1 :: Bool -> Bool-  q1 _ = False--  q2 :: Bool -> Bool -> Bool-  q2 False True = True -  q2 _     _    = False-Solution #34:-  q1 :: Bool -> Bool-  q1 _ = False--  q2 :: Bool -> Bool -> Bool-  q2 True False = True -  q2 True True  = True -  q2 _    _     = False-Solution #35:-  q1 :: Bool -> Bool-  q1 _ = False--  q2 :: Bool -> Bool -> Bool-  q2 False True = True -  q2 True  True = True -  q2 _     _    = False-Solution #36:-  q1 :: Bool -> Bool-  q1 True = True -  q1 _    = False--  q2 :: Bool -> Bool -> Bool-  q2 False True = True -  q2 True  True = True -  q2 _     _    = False-Solution #37:-  q1 :: Bool -> Bool-  q1 _ = False--  q2 :: Bool -> Bool -> Bool-  q2 True True = True -  q2 _    _    = False-Solution #38:-  q1 :: Bool -> Bool-  q1 _ = False--  q2 :: Bool -> Bool -> Bool-  q2 False False = False-  q2 _     _     = True -Solution #39:-  q1 :: Bool -> Bool-  q1 True = False-  q1 _    = True --  q2 :: Bool -> Bool -> Bool-  q2 False False = False-  q2 _     _     = True -Solution #40:-  q1 :: Bool -> Bool-  q1 True = False-  q1 _    = True --  q2 :: Bool -> Bool -> Bool-  q2 True  True  = False-  q2 False False = False-  q2 _     _     = True -Solution #41:-  q1 :: Bool -> Bool-  q1 _ = True--  q2 :: Bool -> Bool -> Bool-  q2 False True  = True -  q2 True  False = True -  q2 _     _     = False-Solution #42:-  q1 :: Bool -> Bool-  q1 _ = True--  q2 :: Bool -> Bool -> Bool-  q2 False False = False-  q2 _     _     = True -Solution #43:-  q1 :: Bool -> Bool-  q1 _ = True--  q2 :: Bool -> Bool -> Bool-  q2 False True  = False-  q2 False False = False-  q2 _     _     = True -Solution #44:-  q1 :: Bool -> Bool-  q1 _ = True--  q2 :: Bool -> Bool -> Bool-  q2 True False = True -  q2 _    _     = False-Solution #45:-  q1 :: Bool -> Bool-  q1 True = False-  q1 _    = True --  q2 :: Bool -> Bool -> Bool-  q2 True False = True -  q2 _    _     = False-Solution #46:-  q1 :: Bool -> Bool-  q1 True = False-  q1 _    = True --  q2 :: Bool -> Bool -> Bool-  q2 True False = True -  q2 True True  = True -  q2 _    _     = False-Solution #47:-  q1 :: Bool -> Bool-  q1 True = False-  q1 _    = True --  q2 :: Bool -> Bool -> Bool-  q2 False True = True -  q2 True  True = True -  q2 _     _    = False-Solution #48:-  q1 :: Bool -> Bool-  q1 _ = True--  q2 :: Bool -> Bool -> Bool-  q2 False True = True -  q2 True  True = True -  q2 _     _    = False-Solution #49:-  q1 :: Bool -> Bool-  q1 _ = True--  q2 :: Bool -> Bool -> Bool-  q2 True True = True -  q2 _    _    = False-Solution #50:-  q1 :: Bool -> Bool-  q1 True = False-  q1 _    = True --  q2 :: Bool -> Bool -> Bool-  q2 _ _ = False-Solution #51:-  q1 :: Bool -> Bool-  q1 _ = True--  q2 :: Bool -> Bool -> Bool-  q2 False False = True -  q2 _     _     = False-Solution #52:-  q1 :: Bool -> Bool-  q1 _ = True--  q2 :: Bool -> Bool -> Bool-  q2 False False = True -  q2 False True  = True -  q2 _     _     = False-Solution #53:-  q1 :: Bool -> Bool-  q1 True = True -  q1 _    = False--  q2 :: Bool -> Bool -> Bool-  q2 False False = False-  q2 True  True  = False-  q2 _     _     = True -Solution #54:-  q1 :: Bool -> Bool-  q1 _ = False--  q2 :: Bool -> Bool -> Bool-  q2 False False = False-  q2 True  True  = False-  q2 _     _     = True -Solution #55:-  q1 :: Bool -> Bool-  q1 _ = True--  q2 :: Bool -> Bool -> Bool-  q2 False True = True -  q2 _     _    = False-Solution #56:-  q1 :: Bool -> Bool-  q1 True = True -  q1 _    = False--  q2 :: Bool -> Bool -> Bool-  q2 False True  = False-  q2 False False = False-  q2 _     _     = True -Solution #57:-  q1 :: Bool -> Bool-  q1 True = False-  q1 _    = True --  q2 :: Bool -> Bool -> Bool-  q2 True True = True -  q2 _    _    = False-Solution #58:-  q1 :: Bool -> Bool-  q1 True = False-  q1 _    = True --  q2 :: Bool -> Bool -> Bool-  q2 False True = True -  q2 _     _    = False-Solution #59:-  q1 :: Bool -> Bool-  q1 True = True -  q1 _    = False--  q2 :: Bool -> Bool -> Bool-  q2 _ _ = True-Solution #60:-  q1 :: Bool -> Bool-  q1 _ = False--  q2 :: Bool -> Bool -> Bool-  q2 True False = False-  q2 True True  = False-  q2 _    _     = True -Solution #61:-  q1 :: Bool -> Bool-  q1 True = True -  q1 _    = False--  q2 :: Bool -> Bool -> Bool-  q2 True False = False-  q2 True True  = False-  q2 _    _     = True -Solution #62:-  q1 :: Bool -> Bool-  q1 True = False-  q1 _    = True --  q2 :: Bool -> Bool -> Bool-  q2 True False = False-  q2 True True  = False-  q2 _    _     = True -Solution #63:-  q1 :: Bool -> Bool-  q1 True = False-  q1 _    = True --  q2 :: Bool -> Bool -> Bool-  q2 True False = False-  q2 _    _     = True -Solution #64:-  q1 :: Bool -> Bool-  q1 _ = True--  q2 :: Bool -> Bool -> Bool-  q2 True False = False-  q2 _    _     = True +[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and (not x!1) (not x!2)))))+[SEND] (get-value ((q2 false false)))+[RECV] (((q2 false false) true))+[SEND] (get-value ((q2 false true)))+[RECV] (((q2 false true) false))+[SEND] (get-value ((q2 true false)))+[RECV] (((q2 true false) false))+[SEND] (get-value ((q2 true true)))+[RECV] (((q2 true true) false))+[GOOD] (define-fun q1_model6 ((x!0 Bool)) Bool+          (ite (and (= x!0 true)) true+          false)+       )+[GOOD] (define-fun q1_model6_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1        x!0)+                            (q1_model6 x!0))))+[GOOD] (define-fun q2_model6 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 false) (= x!1 false)) true+          false)+       )+[GOOD] (define-fun q2_model6_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2        x!0 x!1)+                            (q2_model6 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_6 () Bool +               (or q1_model6_reject+                   q2_model6_reject+               ))+[GOOD] (assert uiFunRejector_model_6)+Looking for solution 7+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 (lambda ((x!1 Bool)) x!1)))+[SEND] (get-value (q2))+[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (or (and x!1 x!2) (and (not x!1) (not x!2))))))+[SEND] (get-value ((q2 false false)))+[RECV] (((q2 false false) true))+[SEND] (get-value ((q2 false true)))+[RECV] (((q2 false true) false))+[SEND] (get-value ((q2 true false)))+[RECV] (((q2 true false) false))+[SEND] (get-value ((q2 true true)))+[RECV] (((q2 true true) true))+[GOOD] (define-fun q1_model7 ((x!0 Bool)) Bool+          (ite (and (= x!0 true)) true+          false)+       )+[GOOD] (define-fun q1_model7_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1        x!0)+                            (q1_model7 x!0))))+[GOOD] (define-fun q2_model7 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 false) (= x!1 false)) true+          (ite (and (= x!0 true) (= x!1 true)) true+          false))+       )+[GOOD] (define-fun q2_model7_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2        x!0 x!1)+                            (q2_model7 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_7 () Bool +               (or q1_model7_reject+                   q2_model7_reject+               ))+[GOOD] (assert uiFunRejector_model_7)+Looking for solution 8+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 ((as const Array) false)))+[SEND] (get-value (q2))+[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (or (and x!1 x!2) (and (not x!1) (not x!2))))))+[SEND] (get-value ((q2 false false)))+[RECV] (((q2 false false) true))+[SEND] (get-value ((q2 false true)))+[RECV] (((q2 false true) false))+[SEND] (get-value ((q2 true false)))+[RECV] (((q2 true false) false))+[SEND] (get-value ((q2 true true)))+[RECV] (((q2 true true) true))+[GOOD] (define-fun q1_model8 ((x!0 Bool)) Bool+          false+       )+[GOOD] (define-fun q1_model8_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1        x!0)+                            (q1_model8 x!0))))+[GOOD] (define-fun q2_model8 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 false) (= x!1 false)) true+          (ite (and (= x!0 true) (= x!1 true)) true+          false))+       )+[GOOD] (define-fun q2_model8_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2        x!0 x!1)+                            (q2_model8 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_8 () Bool +               (or q1_model8_reject+                   q2_model8_reject+               ))+[GOOD] (assert uiFunRejector_model_8)+Looking for solution 9+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 (lambda ((x!1 Bool)) (not x!1))))+[SEND] (get-value (q2))+[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (or (and x!1 x!2) (and (not x!1) (not x!2))))))+[SEND] (get-value ((q2 false false)))+[RECV] (((q2 false false) true))+[SEND] (get-value ((q2 false true)))+[RECV] (((q2 false true) false))+[SEND] (get-value ((q2 true false)))+[RECV] (((q2 true false) false))+[SEND] (get-value ((q2 true true)))+[RECV] (((q2 true true) true))+[GOOD] (define-fun q1_model9 ((x!0 Bool)) Bool+          (ite (and (= x!0 true)) false+          true)+       )+[GOOD] (define-fun q1_model9_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1        x!0)+                            (q1_model9 x!0))))+[GOOD] (define-fun q2_model9 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 false) (= x!1 false)) true+          (ite (and (= x!0 true) (= x!1 true)) true+          false))+       )+[GOOD] (define-fun q2_model9_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2        x!0 x!1)+                            (q2_model9 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_9 () Bool +               (or q1_model9_reject+                   q2_model9_reject+               ))+[GOOD] (assert uiFunRejector_model_9)+Looking for solution 10+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 ((as const Array) false)))+[SEND] (get-value (q2))+[RECV] ((q2 (store ((as const Array) true) false true false)))+[GOOD] (define-fun q1_model10 ((x!0 Bool)) Bool+          false+       )+[GOOD] (define-fun q1_model10_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model10 x!0))))+[GOOD] (define-fun q2_model10 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 false) (= x!1 true)) false+          true)+       )+[GOOD] (define-fun q2_model10_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model10 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_10 () Bool +               (or q1_model10_reject+                   q2_model10_reject+               ))+[GOOD] (assert uiFunRejector_model_10)+Looking for solution 11+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 (lambda ((x!1 Bool)) (not x!1))))+[SEND] (get-value (q2))+[RECV] ((q2 (store ((as const Array) true) false true false)))+[GOOD] (define-fun q1_model11 ((x!0 Bool)) Bool+          (ite (and (= x!0 true)) false+          true)+       )+[GOOD] (define-fun q1_model11_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model11 x!0))))+[GOOD] (define-fun q2_model11 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 false) (= x!1 true)) false+          true)+       )+[GOOD] (define-fun q2_model11_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model11 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_11 () Bool +               (or q1_model11_reject+                   q2_model11_reject+               ))+[GOOD] (assert uiFunRejector_model_11)+Looking for solution 12+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 ((as const Array) true)))+[SEND] (get-value (q2))+[RECV] ((q2 (store (store ((as const Array) true) false true false) true false false)))+[GOOD] (define-fun q1_model12 ((x!0 Bool)) Bool+          true+       )+[GOOD] (define-fun q1_model12_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model12 x!0))))+[GOOD] (define-fun q2_model12 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 true) (= x!1 false)) false+          (ite (and (= x!0 false) (= x!1 true)) false+          true))+       )+[GOOD] (define-fun q2_model12_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model12 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_12 () Bool +               (or q1_model12_reject+                   q2_model12_reject+               ))+[GOOD] (assert uiFunRejector_model_12)+Looking for solution 13+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 ((as const Array) true)))+[SEND] (get-value (q2))+[RECV] ((q2 (store ((as const Array) true) false true false)))+[GOOD] (define-fun q1_model13 ((x!0 Bool)) Bool+          true+       )+[GOOD] (define-fun q1_model13_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model13 x!0))))+[GOOD] (define-fun q2_model13 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 false) (= x!1 true)) false+          true)+       )+[GOOD] (define-fun q2_model13_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model13 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_13 () Bool +               (or q1_model13_reject+                   q2_model13_reject+               ))+[GOOD] (assert uiFunRejector_model_13)+Looking for solution 14+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 (lambda ((x!1 Bool)) x!1)))+[SEND] (get-value (q2))+[RECV] ((q2 (store ((as const Array) true) false true false)))+[GOOD] (define-fun q1_model14 ((x!0 Bool)) Bool+          (ite (and (= x!0 true)) true+          false)+       )+[GOOD] (define-fun q1_model14_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model14 x!0))))+[GOOD] (define-fun q2_model14 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 false) (= x!1 true)) false+          true)+       )+[GOOD] (define-fun q2_model14_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model14 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_14 () Bool +               (or q1_model14_reject+                   q2_model14_reject+               ))+[GOOD] (assert uiFunRejector_model_14)+Looking for solution 15+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 (lambda ((x!1 Bool)) x!1)))+[SEND] (get-value (q2))+[RECV] ((q2 ((as const Array) true)))+[GOOD] (define-fun q1_model15 ((x!0 Bool)) Bool+          (ite (and (= x!0 true)) true+          false)+       )+[GOOD] (define-fun q1_model15_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model15 x!0))))+[GOOD] (define-fun q2_model15 ((x!0 Bool) (x!1 Bool)) Bool+          true+       )+[GOOD] (define-fun q2_model15_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model15 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_15 () Bool +               (or q1_model15_reject+                   q2_model15_reject+               ))+[GOOD] (assert uiFunRejector_model_15)+Looking for solution 16+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 (store ((as const Array) true) true false)))+[SEND] (get-value (q2))+[RECV] ((q2 ((as const Array) true)))+[GOOD] (define-fun q1_model16 ((x!0 Bool)) Bool+          (ite (and (= x!0 true)) false+          true)+       )+[GOOD] (define-fun q1_model16_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model16 x!0))))+[GOOD] (define-fun q2_model16 ((x!0 Bool) (x!1 Bool)) Bool+          true+       )+[GOOD] (define-fun q2_model16_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model16 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_16 () Bool +               (or q1_model16_reject+                   q2_model16_reject+               ))+[GOOD] (assert uiFunRejector_model_16)+Looking for solution 17+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 (store ((as const Array) true) true false)))+[SEND] (get-value (q2))+[RECV] ((q2 (store ((as const Array) true) true false false)))+[GOOD] (define-fun q1_model17 ((x!0 Bool)) Bool+          (ite (and (= x!0 true)) false+          true)+       )+[GOOD] (define-fun q1_model17_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model17 x!0))))+[GOOD] (define-fun q2_model17 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 true) (= x!1 false)) false+          true)+       )+[GOOD] (define-fun q2_model17_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model17 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_17 () Bool +               (or q1_model17_reject+                   q2_model17_reject+               ))+[GOOD] (assert uiFunRejector_model_17)+Looking for solution 18+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 ((as const Array) true)))+[SEND] (get-value (q2))+[RECV] ((q2 (store ((as const Array) true) true false false)))+[GOOD] (define-fun q1_model18 ((x!0 Bool)) Bool+          true+       )+[GOOD] (define-fun q1_model18_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model18 x!0))))+[GOOD] (define-fun q2_model18 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 true) (= x!1 false)) false+          true)+       )+[GOOD] (define-fun q2_model18_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model18 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_18 () Bool +               (or q1_model18_reject+                   q2_model18_reject+               ))+[GOOD] (assert uiFunRejector_model_18)+Looking for solution 19+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 ((as const Array) true)))+[SEND] (get-value (q2))+[RECV] ((q2 ((as const Array) true)))+[GOOD] (define-fun q1_model19 ((x!0 Bool)) Bool+          true+       )+[GOOD] (define-fun q1_model19_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model19 x!0))))+[GOOD] (define-fun q2_model19 ((x!0 Bool) (x!1 Bool)) Bool+          true+       )+[GOOD] (define-fun q2_model19_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model19 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_19 () Bool +               (or q1_model19_reject+                   q2_model19_reject+               ))+[GOOD] (assert uiFunRejector_model_19)+Looking for solution 20+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 (store ((as const Array) true) true false)))+[SEND] (get-value (q2))+[RECV] ((q2 ((as const Array) false)))+[GOOD] (define-fun q1_model20 ((x!0 Bool)) Bool+          (ite (and (= x!0 true)) false+          true)+       )+[GOOD] (define-fun q1_model20_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model20 x!0))))+[GOOD] (define-fun q2_model20 ((x!0 Bool) (x!1 Bool)) Bool+          false+       )+[GOOD] (define-fun q2_model20_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model20 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_20 () Bool +               (or q1_model20_reject+                   q2_model20_reject+               ))+[GOOD] (assert uiFunRejector_model_20)+Looking for solution 21+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 (store ((as const Array) true) true false)))+[SEND] (get-value (q2))+[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and x!1 (not x!2)))))+[SEND] (get-value ((q2 false false)))+[RECV] (((q2 false false) false))+[SEND] (get-value ((q2 false true)))+[RECV] (((q2 false true) false))+[SEND] (get-value ((q2 true false)))+[RECV] (((q2 true false) true))+[SEND] (get-value ((q2 true true)))+[RECV] (((q2 true true) false))+[GOOD] (define-fun q1_model21 ((x!0 Bool)) Bool+          (ite (and (= x!0 true)) false+          true)+       )+[GOOD] (define-fun q1_model21_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model21 x!0))))+[GOOD] (define-fun q2_model21 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 true) (= x!1 false)) true+          false)+       )+[GOOD] (define-fun q2_model21_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model21 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_21 () Bool +               (or q1_model21_reject+                   q2_model21_reject+               ))+[GOOD] (assert uiFunRejector_model_21)+Looking for solution 22+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 (store ((as const Array) true) true false)))+[SEND] (get-value (q2))+[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and (not x!1) x!2))))+[SEND] (get-value ((q2 false false)))+[RECV] (((q2 false false) false))+[SEND] (get-value ((q2 false true)))+[RECV] (((q2 false true) true))+[SEND] (get-value ((q2 true false)))+[RECV] (((q2 true false) false))+[SEND] (get-value ((q2 true true)))+[RECV] (((q2 true true) false))+[GOOD] (define-fun q1_model22 ((x!0 Bool)) Bool+          (ite (and (= x!0 true)) false+          true)+       )+[GOOD] (define-fun q1_model22_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model22 x!0))))+[GOOD] (define-fun q2_model22 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 false) (= x!1 true)) true+          false)+       )+[GOOD] (define-fun q2_model22_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model22 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_22 () Bool +               (or q1_model22_reject+                   q2_model22_reject+               ))+[GOOD] (assert uiFunRejector_model_22)+Looking for solution 23+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 (store ((as const Array) true) true false)))+[SEND] (get-value (q2))+[RECV] ((q2 (store ((as const Array) true) false false false)))+[GOOD] (define-fun q1_model23 ((x!0 Bool)) Bool+          (ite (and (= x!0 true)) false+          true)+       )+[GOOD] (define-fun q1_model23_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model23 x!0))))+[GOOD] (define-fun q2_model23 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 false) (= x!1 false)) false+          true)+       )+[GOOD] (define-fun q2_model23_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model23 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_23 () Bool +               (or q1_model23_reject+                   q2_model23_reject+               ))+[GOOD] (assert uiFunRejector_model_23)+Looking for solution 24+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 (store ((as const Array) true) true false)))+[SEND] (get-value (q2))+[RECV] ((q2 (store (store ((as const Array) true) false false false) true true false)))+[GOOD] (define-fun q1_model24 ((x!0 Bool)) Bool+          (ite (and (= x!0 true)) false+          true)+       )+[GOOD] (define-fun q1_model24_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model24 x!0))))+[GOOD] (define-fun q2_model24 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 true) (= x!1 true)) false+          (ite (and (= x!0 false) (= x!1 false)) false+          true))+       )+[GOOD] (define-fun q2_model24_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model24 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_24 () Bool +               (or q1_model24_reject+                   q2_model24_reject+               ))+[GOOD] (assert uiFunRejector_model_24)+Looking for solution 25+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 (store ((as const Array) true) true false)))+[SEND] (get-value (q2))+[RECV] ((q2 (store (store ((as const Array) true) false false false) true false false)))+[GOOD] (define-fun q1_model25 ((x!0 Bool)) Bool+          (ite (and (= x!0 true)) false+          true)+       )+[GOOD] (define-fun q1_model25_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model25 x!0))))+[GOOD] (define-fun q2_model25 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 true) (= x!1 false)) false+          (ite (and (= x!0 false) (= x!1 false)) false+          true))+       )+[GOOD] (define-fun q2_model25_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model25 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_25 () Bool +               (or q1_model25_reject+                   q2_model25_reject+               ))+[GOOD] (assert uiFunRejector_model_25)+Looking for solution 26+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 (store ((as const Array) true) true false)))+[SEND] (get-value (q2))+[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and x!1 x!2))))+[SEND] (get-value ((q2 false false)))+[RECV] (((q2 false false) false))+[SEND] (get-value ((q2 false true)))+[RECV] (((q2 false true) false))+[SEND] (get-value ((q2 true false)))+[RECV] (((q2 true false) false))+[SEND] (get-value ((q2 true true)))+[RECV] (((q2 true true) true))+[GOOD] (define-fun q1_model26 ((x!0 Bool)) Bool+          (ite (and (= x!0 true)) false+          true)+       )+[GOOD] (define-fun q1_model26_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model26 x!0))))+[GOOD] (define-fun q2_model26 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 true) (= x!1 true)) true+          false)+       )+[GOOD] (define-fun q2_model26_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model26 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_26 () Bool +               (or q1_model26_reject+                   q2_model26_reject+               ))+[GOOD] (assert uiFunRejector_model_26)+Looking for solution 27+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 ((as const Array) true)))+[SEND] (get-value (q2))+[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and x!1 x!2))))+[SEND] (get-value ((q2 false false)))+[RECV] (((q2 false false) false))+[SEND] (get-value ((q2 false true)))+[RECV] (((q2 false true) false))+[SEND] (get-value ((q2 true false)))+[RECV] (((q2 true false) false))+[SEND] (get-value ((q2 true true)))+[RECV] (((q2 true true) true))+[GOOD] (define-fun q1_model27 ((x!0 Bool)) Bool+          true+       )+[GOOD] (define-fun q1_model27_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model27 x!0))))+[GOOD] (define-fun q2_model27 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 true) (= x!1 true)) true+          false)+       )+[GOOD] (define-fun q2_model27_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model27 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_27 () Bool +               (or q1_model27_reject+                   q2_model27_reject+               ))+[GOOD] (assert uiFunRejector_model_27)+Looking for solution 28+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 ((as const Array) true)))+[SEND] (get-value (q2))+[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and x!1 (not x!2)))))+[SEND] (get-value ((q2 false false)))+[RECV] (((q2 false false) false))+[SEND] (get-value ((q2 false true)))+[RECV] (((q2 false true) false))+[SEND] (get-value ((q2 true false)))+[RECV] (((q2 true false) true))+[SEND] (get-value ((q2 true true)))+[RECV] (((q2 true true) false))+[GOOD] (define-fun q1_model28 ((x!0 Bool)) Bool+          true+       )+[GOOD] (define-fun q1_model28_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model28 x!0))))+[GOOD] (define-fun q2_model28 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 true) (= x!1 false)) true+          false)+       )+[GOOD] (define-fun q2_model28_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model28 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_28 () Bool +               (or q1_model28_reject+                   q2_model28_reject+               ))+[GOOD] (assert uiFunRejector_model_28)+Looking for solution 29+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 ((as const Array) true)))+[SEND] (get-value (q2))+[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (or (and x!1 x!2) (and x!1 (not x!2))))))+[SEND] (get-value ((q2 false false)))+[RECV] (((q2 false false) false))+[SEND] (get-value ((q2 false true)))+[RECV] (((q2 false true) false))+[SEND] (get-value ((q2 true false)))+[RECV] (((q2 true false) true))+[SEND] (get-value ((q2 true true)))+[RECV] (((q2 true true) true))+[GOOD] (define-fun q1_model29 ((x!0 Bool)) Bool+          true+       )+[GOOD] (define-fun q1_model29_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model29 x!0))))+[GOOD] (define-fun q2_model29 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 true) (= x!1 false)) true+          (ite (and (= x!0 true) (= x!1 true)) true+          false))+       )+[GOOD] (define-fun q2_model29_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model29 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_29 () Bool +               (or q1_model29_reject+                   q2_model29_reject+               ))+[GOOD] (assert uiFunRejector_model_29)+Looking for solution 30+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 (store ((as const Array) true) true false)))+[SEND] (get-value (q2))+[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (or (and x!1 x!2) (and x!1 (not x!2))))))+[SEND] (get-value ((q2 false false)))+[RECV] (((q2 false false) false))+[SEND] (get-value ((q2 false true)))+[RECV] (((q2 false true) false))+[SEND] (get-value ((q2 true false)))+[RECV] (((q2 true false) true))+[SEND] (get-value ((q2 true true)))+[RECV] (((q2 true true) true))+[GOOD] (define-fun q1_model30 ((x!0 Bool)) Bool+          (ite (and (= x!0 true)) false+          true)+       )+[GOOD] (define-fun q1_model30_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model30 x!0))))+[GOOD] (define-fun q2_model30 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 true) (= x!1 false)) true+          (ite (and (= x!0 true) (= x!1 true)) true+          false))+       )+[GOOD] (define-fun q2_model30_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model30 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_30 () Bool +               (or q1_model30_reject+                   q2_model30_reject+               ))+[GOOD] (assert uiFunRejector_model_30)+Looking for solution 31+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 ((as const Array) true)))+[SEND] (get-value (q2))+[RECV] ((q2 (store ((as const Array) true) false false false)))+[GOOD] (define-fun q1_model31 ((x!0 Bool)) Bool+          true+       )+[GOOD] (define-fun q1_model31_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model31 x!0))))+[GOOD] (define-fun q2_model31 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 false) (= x!1 false)) false+          true)+       )+[GOOD] (define-fun q2_model31_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model31 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_31 () Bool +               (or q1_model31_reject+                   q2_model31_reject+               ))+[GOOD] (assert uiFunRejector_model_31)+Looking for solution 32+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 ((as const Array) true)))+[SEND] (get-value (q2))+[RECV] ((q2 (store (store ((as const Array) true) false false false) true true false)))+[GOOD] (define-fun q1_model32 ((x!0 Bool)) Bool+          true+       )+[GOOD] (define-fun q1_model32_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model32 x!0))))+[GOOD] (define-fun q2_model32 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 true) (= x!1 true)) false+          (ite (and (= x!0 false) (= x!1 false)) false+          true))+       )+[GOOD] (define-fun q2_model32_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model32 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_32 () Bool +               (or q1_model32_reject+                   q2_model32_reject+               ))+[GOOD] (assert uiFunRejector_model_32)+Looking for solution 33+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 (lambda ((x!1 Bool)) x!1)))+[SEND] (get-value (q2))+[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and x!1 (not x!2)))))+[SEND] (get-value ((q2 false false)))+[RECV] (((q2 false false) false))+[SEND] (get-value ((q2 false true)))+[RECV] (((q2 false true) false))+[SEND] (get-value ((q2 true false)))+[RECV] (((q2 true false) true))+[SEND] (get-value ((q2 true true)))+[RECV] (((q2 true true) false))+[GOOD] (define-fun q1_model33 ((x!0 Bool)) Bool+          (ite (and (= x!0 true)) true+          false)+       )+[GOOD] (define-fun q1_model33_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model33 x!0))))+[GOOD] (define-fun q2_model33 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 true) (= x!1 false)) true+          false)+       )+[GOOD] (define-fun q2_model33_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model33 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_33 () Bool +               (or q1_model33_reject+                   q2_model33_reject+               ))+[GOOD] (assert uiFunRejector_model_33)+Looking for solution 34+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 (lambda ((x!1 Bool)) x!1)))+[SEND] (get-value (q2))+[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (or (and (not x!1) x!2) (and x!1 (not x!2))))))+[SEND] (get-value ((q2 false false)))+[RECV] (((q2 false false) false))+[SEND] (get-value ((q2 false true)))+[RECV] (((q2 false true) true))+[SEND] (get-value ((q2 true false)))+[RECV] (((q2 true false) true))+[SEND] (get-value ((q2 true true)))+[RECV] (((q2 true true) false))+[GOOD] (define-fun q1_model34 ((x!0 Bool)) Bool+          (ite (and (= x!0 true)) true+          false)+       )+[GOOD] (define-fun q1_model34_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model34 x!0))))+[GOOD] (define-fun q2_model34 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 false) (= x!1 true)) true+          (ite (and (= x!0 true) (= x!1 false)) true+          false))+       )+[GOOD] (define-fun q2_model34_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model34 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_34 () Bool +               (or q1_model34_reject+                   q2_model34_reject+               ))+[GOOD] (assert uiFunRejector_model_34)+Looking for solution 35+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 (lambda ((x!1 Bool)) x!1)))+[SEND] (get-value (q2))+[RECV] ((q2 (store (store ((as const Array) true) false false false) false true false)))+[GOOD] (define-fun q1_model35 ((x!0 Bool)) Bool+          (ite (and (= x!0 true)) true+          false)+       )+[GOOD] (define-fun q1_model35_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model35 x!0))))+[GOOD] (define-fun q2_model35 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 false) (= x!1 true)) false+          (ite (and (= x!0 false) (= x!1 false)) false+          true))+       )+[GOOD] (define-fun q2_model35_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model35 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_35 () Bool +               (or q1_model35_reject+                   q2_model35_reject+               ))+[GOOD] (assert uiFunRejector_model_35)+Looking for solution 36+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 (lambda ((x!1 Bool)) x!1)))+[SEND] (get-value (q2))+[RECV] ((q2 (store ((as const Array) true) false false false)))+[GOOD] (define-fun q1_model36 ((x!0 Bool)) Bool+          (ite (and (= x!0 true)) true+          false)+       )+[GOOD] (define-fun q1_model36_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model36 x!0))))+[GOOD] (define-fun q2_model36 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 false) (= x!1 false)) false+          true)+       )+[GOOD] (define-fun q2_model36_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model36 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_36 () Bool +               (or q1_model36_reject+                   q2_model36_reject+               ))+[GOOD] (assert uiFunRejector_model_36)+Looking for solution 37+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 (lambda ((x!1 Bool)) x!1)))+[SEND] (get-value (q2))+[RECV] ((q2 (store ((as const Array) true) true true false)))+[GOOD] (define-fun q1_model37 ((x!0 Bool)) Bool+          (ite (and (= x!0 true)) true+          false)+       )+[GOOD] (define-fun q1_model37_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model37 x!0))))+[GOOD] (define-fun q2_model37 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 true) (= x!1 true)) false+          true)+       )+[GOOD] (define-fun q2_model37_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model37 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_37 () Bool +               (or q1_model37_reject+                   q2_model37_reject+               ))+[GOOD] (assert uiFunRejector_model_37)+Looking for solution 38+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 (lambda ((x!1 Bool)) x!1)))+[SEND] (get-value (q2))+[RECV] ((q2 (store (store ((as const Array) true) true true false) false true false)))+[GOOD] (define-fun q1_model38 ((x!0 Bool)) Bool+          (ite (and (= x!0 true)) true+          false)+       )+[GOOD] (define-fun q1_model38_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model38 x!0))))+[GOOD] (define-fun q2_model38 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 false) (= x!1 true)) false+          (ite (and (= x!0 true) (= x!1 true)) false+          true))+       )+[GOOD] (define-fun q2_model38_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model38 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_38 () Bool +               (or q1_model38_reject+                   q2_model38_reject+               ))+[GOOD] (assert uiFunRejector_model_38)+Looking for solution 39+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 ((as const Array) true)))+[SEND] (get-value (q2))+[RECV] ((q2 (store (store ((as const Array) true) true true false) false true false)))+[GOOD] (define-fun q1_model39 ((x!0 Bool)) Bool+          true+       )+[GOOD] (define-fun q1_model39_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model39 x!0))))+[GOOD] (define-fun q2_model39 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 false) (= x!1 true)) false+          (ite (and (= x!0 true) (= x!1 true)) false+          true))+       )+[GOOD] (define-fun q2_model39_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model39 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_39 () Bool +               (or q1_model39_reject+                   q2_model39_reject+               ))+[GOOD] (assert uiFunRejector_model_39)+Looking for solution 40+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 ((as const Array) true)))+[SEND] (get-value (q2))+[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and (not x!1) (not x!2)))))+[SEND] (get-value ((q2 false false)))+[RECV] (((q2 false false) true))+[SEND] (get-value ((q2 false true)))+[RECV] (((q2 false true) false))+[SEND] (get-value ((q2 true false)))+[RECV] (((q2 true false) false))+[SEND] (get-value ((q2 true true)))+[RECV] (((q2 true true) false))+[GOOD] (define-fun q1_model40 ((x!0 Bool)) Bool+          true+       )+[GOOD] (define-fun q1_model40_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model40 x!0))))+[GOOD] (define-fun q2_model40 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 false) (= x!1 false)) true+          false)+       )+[GOOD] (define-fun q2_model40_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model40 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_40 () Bool +               (or q1_model40_reject+                   q2_model40_reject+               ))+[GOOD] (assert uiFunRejector_model_40)+Looking for solution 41+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 (store ((as const Array) true) true false)))+[SEND] (get-value (q2))+[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and (not x!1) (not x!2)))))+[SEND] (get-value ((q2 false false)))+[RECV] (((q2 false false) true))+[SEND] (get-value ((q2 false true)))+[RECV] (((q2 false true) false))+[SEND] (get-value ((q2 true false)))+[RECV] (((q2 true false) false))+[SEND] (get-value ((q2 true true)))+[RECV] (((q2 true true) false))+[GOOD] (define-fun q1_model41 ((x!0 Bool)) Bool+          (ite (and (= x!0 true)) false+          true)+       )+[GOOD] (define-fun q1_model41_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model41 x!0))))+[GOOD] (define-fun q2_model41 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 false) (= x!1 false)) true+          false)+       )+[GOOD] (define-fun q2_model41_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model41 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_41 () Bool +               (or q1_model41_reject+                   q2_model41_reject+               ))+[GOOD] (assert uiFunRejector_model_41)+Looking for solution 42+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 ((as const Array) false)))+[SEND] (get-value (q2))+[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and (not x!1) x!2))))+[SEND] (get-value ((q2 false false)))+[RECV] (((q2 false false) false))+[SEND] (get-value ((q2 false true)))+[RECV] (((q2 false true) true))+[SEND] (get-value ((q2 true false)))+[RECV] (((q2 true false) false))+[SEND] (get-value ((q2 true true)))+[RECV] (((q2 true true) false))+[GOOD] (define-fun q1_model42 ((x!0 Bool)) Bool+          false+       )+[GOOD] (define-fun q1_model42_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model42 x!0))))+[GOOD] (define-fun q2_model42 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 false) (= x!1 true)) true+          false)+       )+[GOOD] (define-fun q2_model42_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model42 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_42 () Bool +               (or q1_model42_reject+                   q2_model42_reject+               ))+[GOOD] (assert uiFunRejector_model_42)+Looking for solution 43+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 ((as const Array) false)))+[SEND] (get-value (q2))+[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and x!1 x!2))))+[SEND] (get-value ((q2 false false)))+[RECV] (((q2 false false) false))+[SEND] (get-value ((q2 false true)))+[RECV] (((q2 false true) false))+[SEND] (get-value ((q2 true false)))+[RECV] (((q2 true false) false))+[SEND] (get-value ((q2 true true)))+[RECV] (((q2 true true) true))+[GOOD] (define-fun q1_model43 ((x!0 Bool)) Bool+          false+       )+[GOOD] (define-fun q1_model43_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model43 x!0))))+[GOOD] (define-fun q2_model43 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 true) (= x!1 true)) true+          false)+       )+[GOOD] (define-fun q2_model43_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model43 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_43 () Bool +               (or q1_model43_reject+                   q2_model43_reject+               ))+[GOOD] (assert uiFunRejector_model_43)+Looking for solution 44+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 ((as const Array) true)))+[SEND] (get-value (q2))+[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and (not x!1) x!2))))+[SEND] (get-value ((q2 false false)))+[RECV] (((q2 false false) false))+[SEND] (get-value ((q2 false true)))+[RECV] (((q2 false true) true))+[SEND] (get-value ((q2 true false)))+[RECV] (((q2 true false) false))+[SEND] (get-value ((q2 true true)))+[RECV] (((q2 true true) false))+[GOOD] (define-fun q1_model44 ((x!0 Bool)) Bool+          true+       )+[GOOD] (define-fun q1_model44_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model44 x!0))))+[GOOD] (define-fun q2_model44 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 false) (= x!1 true)) true+          false)+       )+[GOOD] (define-fun q2_model44_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model44 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_44 () Bool +               (or q1_model44_reject+                   q2_model44_reject+               ))+[GOOD] (assert uiFunRejector_model_44)+Looking for solution 45+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 ((as const Array) false)))+[SEND] (get-value (q2))+[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and x!1 (not x!2)))))+[SEND] (get-value ((q2 false false)))+[RECV] (((q2 false false) false))+[SEND] (get-value ((q2 false true)))+[RECV] (((q2 false true) false))+[SEND] (get-value ((q2 true false)))+[RECV] (((q2 true false) true))+[SEND] (get-value ((q2 true true)))+[RECV] (((q2 true true) false))+[GOOD] (define-fun q1_model45 ((x!0 Bool)) Bool+          false+       )+[GOOD] (define-fun q1_model45_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model45 x!0))))+[GOOD] (define-fun q2_model45 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 true) (= x!1 false)) true+          false)+       )+[GOOD] (define-fun q2_model45_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model45 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_45 () Bool +               (or q1_model45_reject+                   q2_model45_reject+               ))+[GOOD] (assert uiFunRejector_model_45)+Looking for solution 46+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 (lambda ((x!1 Bool)) x!1)))+[SEND] (get-value (q2))+[RECV] ((q2 ((as const Array) false)))+[GOOD] (define-fun q1_model46 ((x!0 Bool)) Bool+          (ite (and (= x!0 true)) true+          false)+       )+[GOOD] (define-fun q1_model46_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model46 x!0))))+[GOOD] (define-fun q2_model46 ((x!0 Bool) (x!1 Bool)) Bool+          false+       )+[GOOD] (define-fun q2_model46_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model46 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_46 () Bool +               (or q1_model46_reject+                   q2_model46_reject+               ))+[GOOD] (assert uiFunRejector_model_46)+Looking for solution 47+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 (lambda ((x!1 Bool)) x!1)))+[SEND] (get-value (q2))+[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and x!1 x!2))))+[SEND] (get-value ((q2 false false)))+[RECV] (((q2 false false) false))+[SEND] (get-value ((q2 false true)))+[RECV] (((q2 false true) false))+[SEND] (get-value ((q2 true false)))+[RECV] (((q2 true false) false))+[SEND] (get-value ((q2 true true)))+[RECV] (((q2 true true) true))+[GOOD] (define-fun q1_model47 ((x!0 Bool)) Bool+          (ite (and (= x!0 true)) true+          false)+       )+[GOOD] (define-fun q1_model47_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model47 x!0))))+[GOOD] (define-fun q2_model47 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 true) (= x!1 true)) true+          false)+       )+[GOOD] (define-fun q2_model47_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model47 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_47 () Bool +               (or q1_model47_reject+                   q2_model47_reject+               ))+[GOOD] (assert uiFunRejector_model_47)+Looking for solution 48+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 ((as const Array) false)))+[SEND] (get-value (q2))+[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (or (and x!1 x!2) (and x!1 (not x!2))))))+[SEND] (get-value ((q2 false false)))+[RECV] (((q2 false false) false))+[SEND] (get-value ((q2 false true)))+[RECV] (((q2 false true) false))+[SEND] (get-value ((q2 true false)))+[RECV] (((q2 true false) true))+[SEND] (get-value ((q2 true true)))+[RECV] (((q2 true true) true))+[GOOD] (define-fun q1_model48 ((x!0 Bool)) Bool+          false+       )+[GOOD] (define-fun q1_model48_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model48 x!0))))+[GOOD] (define-fun q2_model48 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 true) (= x!1 false)) true+          (ite (and (= x!0 true) (= x!1 true)) true+          false))+       )+[GOOD] (define-fun q2_model48_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model48 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_48 () Bool +               (or q1_model48_reject+                   q2_model48_reject+               ))+[GOOD] (assert uiFunRejector_model_48)+Looking for solution 49+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 ((as const Array) false)))+[SEND] (get-value (q2))+[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (or (and (not x!1) x!2) (and x!1 x!2)))))+[SEND] (get-value ((q2 false false)))+[RECV] (((q2 false false) false))+[SEND] (get-value ((q2 false true)))+[RECV] (((q2 false true) true))+[SEND] (get-value ((q2 true false)))+[RECV] (((q2 true false) false))+[SEND] (get-value ((q2 true true)))+[RECV] (((q2 true true) true))+[GOOD] (define-fun q1_model49 ((x!0 Bool)) Bool+          false+       )+[GOOD] (define-fun q1_model49_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model49 x!0))))+[GOOD] (define-fun q2_model49 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 false) (= x!1 true)) true+          (ite (and (= x!0 true) (= x!1 true)) true+          false))+       )+[GOOD] (define-fun q2_model49_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model49 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_49 () Bool +               (or q1_model49_reject+                   q2_model49_reject+               ))+[GOOD] (assert uiFunRejector_model_49)+Looking for solution 50+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 (lambda ((x!1 Bool)) x!1)))+[SEND] (get-value (q2))+[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and (not x!1) x!2))))+[SEND] (get-value ((q2 false false)))+[RECV] (((q2 false false) false))+[SEND] (get-value ((q2 false true)))+[RECV] (((q2 false true) true))+[SEND] (get-value ((q2 true false)))+[RECV] (((q2 true false) false))+[SEND] (get-value ((q2 true true)))+[RECV] (((q2 true true) false))+[GOOD] (define-fun q1_model50 ((x!0 Bool)) Bool+          (ite (and (= x!0 true)) true+          false)+       )+[GOOD] (define-fun q1_model50_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model50 x!0))))+[GOOD] (define-fun q2_model50 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 false) (= x!1 true)) true+          false)+       )+[GOOD] (define-fun q2_model50_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model50 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_50 () Bool +               (or q1_model50_reject+                   q2_model50_reject+               ))+[GOOD] (assert uiFunRejector_model_50)+Looking for solution 51+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 (lambda ((x!1 Bool)) x!1)))+[SEND] (get-value (q2))+[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (or (and x!1 x!2) (and (not x!1) x!2)))))+[SEND] (get-value ((q2 false false)))+[RECV] (((q2 false false) false))+[SEND] (get-value ((q2 false true)))+[RECV] (((q2 false true) true))+[SEND] (get-value ((q2 true false)))+[RECV] (((q2 true false) false))+[SEND] (get-value ((q2 true true)))+[RECV] (((q2 true true) true))+[GOOD] (define-fun q1_model51 ((x!0 Bool)) Bool+          (ite (and (= x!0 true)) true+          false)+       )+[GOOD] (define-fun q1_model51_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model51 x!0))))+[GOOD] (define-fun q2_model51 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 false) (= x!1 true)) true+          (ite (and (= x!0 true) (= x!1 true)) true+          false))+       )+[GOOD] (define-fun q2_model51_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model51 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_51 () Bool +               (or q1_model51_reject+                   q2_model51_reject+               ))+[GOOD] (assert uiFunRejector_model_51)+Looking for solution 52+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 ((as const Array) false)))+[SEND] (get-value (q2))+[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (or (and (not x!1) x!2) (and x!1 (not x!2))))))+[SEND] (get-value ((q2 false false)))+[RECV] (((q2 false false) false))+[SEND] (get-value ((q2 false true)))+[RECV] (((q2 false true) true))+[SEND] (get-value ((q2 true false)))+[RECV] (((q2 true false) true))+[SEND] (get-value ((q2 true true)))+[RECV] (((q2 true true) false))+[GOOD] (define-fun q1_model52 ((x!0 Bool)) Bool+          false+       )+[GOOD] (define-fun q1_model52_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model52 x!0))))+[GOOD] (define-fun q2_model52 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 false) (= x!1 true)) true+          (ite (and (= x!0 true) (= x!1 false)) true+          false))+       )+[GOOD] (define-fun q2_model52_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model52 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_52 () Bool +               (or q1_model52_reject+                   q2_model52_reject+               ))+[GOOD] (assert uiFunRejector_model_52)+Looking for solution 53+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 ((as const Array) false)))+[SEND] (get-value (q2))+[RECV] ((q2 (store ((as const Array) true) false false false)))+[GOOD] (define-fun q1_model53 ((x!0 Bool)) Bool+          false+       )+[GOOD] (define-fun q1_model53_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model53 x!0))))+[GOOD] (define-fun q2_model53 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 false) (= x!1 false)) false+          true)+       )+[GOOD] (define-fun q2_model53_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model53 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_53 () Bool +               (or q1_model53_reject+                   q2_model53_reject+               ))+[GOOD] (assert uiFunRejector_model_53)+Looking for solution 54+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 ((as const Array) true)))+[SEND] (get-value (q2))+[RECV] ((q2 (store (store ((as const Array) true) false false false) true false false)))+[GOOD] (define-fun q1_model54 ((x!0 Bool)) Bool+          true+       )+[GOOD] (define-fun q1_model54_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model54 x!0))))+[GOOD] (define-fun q2_model54 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 true) (= x!1 false)) false+          (ite (and (= x!0 false) (= x!1 false)) false+          true))+       )+[GOOD] (define-fun q2_model54_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model54 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_54 () Bool +               (or q1_model54_reject+                   q2_model54_reject+               ))+[GOOD] (assert uiFunRejector_model_54)+Looking for solution 55+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 (lambda ((x!1 Bool)) x!1)))+[SEND] (get-value (q2))+[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool))+         (or (and (not x!1) (not x!2)) (and (not x!1) x!2)))))+[SEND] (get-value ((q2 false false)))+[RECV] (((q2 false false) true))+[SEND] (get-value ((q2 false true)))+[RECV] (((q2 false true) true))+[SEND] (get-value ((q2 true false)))+[RECV] (((q2 true false) false))+[SEND] (get-value ((q2 true true)))+[RECV] (((q2 true true) false))+[GOOD] (define-fun q1_model55 ((x!0 Bool)) Bool+          (ite (and (= x!0 true)) true+          false)+       )+[GOOD] (define-fun q1_model55_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model55 x!0))))+[GOOD] (define-fun q2_model55 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 false) (= x!1 false)) true+          (ite (and (= x!0 false) (= x!1 true)) true+          false))+       )+[GOOD] (define-fun q2_model55_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model55 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_55 () Bool +               (or q1_model55_reject+                   q2_model55_reject+               ))+[GOOD] (assert uiFunRejector_model_55)+Looking for solution 56+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 ((as const Array) true)))+[SEND] (get-value (q2))+[RECV] ((q2 (store ((as const Array) true) true true false)))+[GOOD] (define-fun q1_model56 ((x!0 Bool)) Bool+          true+       )+[GOOD] (define-fun q1_model56_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model56 x!0))))+[GOOD] (define-fun q2_model56 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 true) (= x!1 true)) false+          true)+       )+[GOOD] (define-fun q2_model56_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model56 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_56 () Bool +               (or q1_model56_reject+                   q2_model56_reject+               ))+[GOOD] (assert uiFunRejector_model_56)+Looking for solution 57+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 ((as const Array) true)))+[SEND] (get-value (q2))+[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool))+         (or (and (not x!1) (not x!2)) (and (not x!1) x!2)))))+[SEND] (get-value ((q2 false false)))+[RECV] (((q2 false false) true))+[SEND] (get-value ((q2 false true)))+[RECV] (((q2 false true) true))+[SEND] (get-value ((q2 true false)))+[RECV] (((q2 true false) false))+[SEND] (get-value ((q2 true true)))+[RECV] (((q2 true true) false))+[GOOD] (define-fun q1_model57 ((x!0 Bool)) Bool+          true+       )+[GOOD] (define-fun q1_model57_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model57 x!0))))+[GOOD] (define-fun q2_model57 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 false) (= x!1 false)) true+          (ite (and (= x!0 false) (= x!1 true)) true+          false))+       )+[GOOD] (define-fun q2_model57_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model57 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_57 () Bool +               (or q1_model57_reject+                   q2_model57_reject+               ))+[GOOD] (assert uiFunRejector_model_57)+Looking for solution 58+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 ((as const Array) false)))+[SEND] (get-value (q2))+[RECV] ((q2 (store ((as const Array) true) true true false)))+[GOOD] (define-fun q1_model58 ((x!0 Bool)) Bool+          false+       )+[GOOD] (define-fun q1_model58_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model58 x!0))))+[GOOD] (define-fun q2_model58 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 true) (= x!1 true)) false+          true)+       )+[GOOD] (define-fun q2_model58_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model58 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_58 () Bool +               (or q1_model58_reject+                   q2_model58_reject+               ))+[GOOD] (assert uiFunRejector_model_58)+Looking for solution 59+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 (lambda ((x!1 Bool)) (not x!1))))+[SEND] (get-value (q2))+[RECV] ((q2 (store ((as const Array) true) true true false)))+[GOOD] (define-fun q1_model59 ((x!0 Bool)) Bool+          (ite (and (= x!0 true)) false+          true)+       )+[GOOD] (define-fun q1_model59_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model59 x!0))))+[GOOD] (define-fun q2_model59 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 true) (= x!1 true)) false+          true)+       )+[GOOD] (define-fun q2_model59_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model59 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_59 () Bool +               (or q1_model59_reject+                   q2_model59_reject+               ))+[GOOD] (assert uiFunRejector_model_59)+Looking for solution 60+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 (store ((as const Array) true) true false)))+[SEND] (get-value (q2))+[RECV] ((q2 (store (store ((as const Array) true) true true false) false true false)))+[GOOD] (define-fun q1_model60 ((x!0 Bool)) Bool+          (ite (and (= x!0 true)) false+          true)+       )+[GOOD] (define-fun q1_model60_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model60 x!0))))+[GOOD] (define-fun q2_model60 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 false) (= x!1 true)) false+          (ite (and (= x!0 true) (= x!1 true)) false+          true))+       )+[GOOD] (define-fun q2_model60_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model60 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_60 () Bool +               (or q1_model60_reject+                   q2_model60_reject+               ))+[GOOD] (assert uiFunRejector_model_60)+Looking for solution 61+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 (store ((as const Array) true) true false)))+[SEND] (get-value (q2))+[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool))+         (or (and (not x!1) (not x!2)) (and (not x!1) x!2)))))+[SEND] (get-value ((q2 false false)))+[RECV] (((q2 false false) true))+[SEND] (get-value ((q2 false true)))+[RECV] (((q2 false true) true))+[SEND] (get-value ((q2 true false)))+[RECV] (((q2 true false) false))+[SEND] (get-value ((q2 true true)))+[RECV] (((q2 true true) false))+[GOOD] (define-fun q1_model61 ((x!0 Bool)) Bool+          (ite (and (= x!0 true)) false+          true)+       )+[GOOD] (define-fun q1_model61_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model61 x!0))))+[GOOD] (define-fun q2_model61 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 false) (= x!1 false)) true+          (ite (and (= x!0 false) (= x!1 true)) true+          false))+       )+[GOOD] (define-fun q2_model61_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model61 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_61 () Bool +               (or q1_model61_reject+                   q2_model61_reject+               ))+[GOOD] (assert uiFunRejector_model_61)+Looking for solution 62+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 ((as const Array) false)))+[SEND] (get-value (q2))+[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and (not x!1) (not x!2)))))+[SEND] (get-value ((q2 false false)))+[RECV] (((q2 false false) true))+[SEND] (get-value ((q2 false true)))+[RECV] (((q2 false true) false))+[SEND] (get-value ((q2 true false)))+[RECV] (((q2 true false) false))+[SEND] (get-value ((q2 true true)))+[RECV] (((q2 true true) false))+[GOOD] (define-fun q1_model62 ((x!0 Bool)) Bool+          false+       )+[GOOD] (define-fun q1_model62_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model62 x!0))))+[GOOD] (define-fun q2_model62 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 false) (= x!1 false)) true+          false)+       )+[GOOD] (define-fun q2_model62_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model62 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_62 () Bool +               (or q1_model62_reject+                   q2_model62_reject+               ))+[GOOD] (assert uiFunRejector_model_62)+Looking for solution 63+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 ((as const Array) false)))+[SEND] (get-value (q2))+[RECV] ((q2 (store (store ((as const Array) true) true true false) false true false)))+[GOOD] (define-fun q1_model63 ((x!0 Bool)) Bool+          false+       )+[GOOD] (define-fun q1_model63_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model63 x!0))))+[GOOD] (define-fun q2_model63 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 false) (= x!1 true)) false+          (ite (and (= x!0 true) (= x!1 true)) false+          true))+       )+[GOOD] (define-fun q2_model63_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model63 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_63 () Bool +               (or q1_model63_reject+                   q2_model63_reject+               ))+[GOOD] (assert uiFunRejector_model_63)+Looking for solution 64+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (q1))+[RECV] ((q1 ((as const Array) false)))+[SEND] (get-value (q2))+[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool))+         (or (and (not x!1) (not x!2)) (and (not x!1) x!2)))))+[SEND] (get-value ((q2 false false)))+[RECV] (((q2 false false) true))+[SEND] (get-value ((q2 false true)))+[RECV] (((q2 false true) true))+[SEND] (get-value ((q2 true false)))+[RECV] (((q2 true false) false))+[SEND] (get-value ((q2 true true)))+[RECV] (((q2 true true) false))+[GOOD] (define-fun q1_model64 ((x!0 Bool)) Bool+          false+       )+[GOOD] (define-fun q1_model64_reject () Bool+          (exists ((x!0 Bool))+                  (distinct (q1         x!0)+                            (q1_model64 x!0))))+[GOOD] (define-fun q2_model64 ((x!0 Bool) (x!1 Bool)) Bool+          (ite (and (= x!0 false) (= x!1 false)) true+          (ite (and (= x!0 false) (= x!1 true)) true+          false))+       )+[GOOD] (define-fun q2_model64_reject () Bool+          (exists ((x!0 Bool) (x!1 Bool))+                  (distinct (q2         x!0 x!1)+                            (q2_model64 x!0 x!1))))+[GOOD] (define-fun uiFunRejector_model_64 () Bool +               (or q1_model64_reject+                   q2_model64_reject+               ))+[GOOD] (assert uiFunRejector_model_64)+Looking for solution 65+[SEND] (check-sat)+[RECV] unsat+*** Solver   : Z3+*** Exit code: ExitSuccess++RESULT: Solution #1:+  q1 :: Bool -> Bool+  q1 _ = False++  q2 :: Bool -> Bool -> Bool+  q2 _ _ = False+Solution #2:+  q1 :: Bool -> Bool+  q1 _ = True++  q2 :: Bool -> Bool -> Bool+  q2 _ _ = False+Solution #3:+  q1 :: Bool -> Bool+  q1 _ = False++  q2 :: Bool -> Bool -> Bool+  q2 _ _ = True+Solution #4:+  q1 :: Bool -> Bool+  q1 _ = False++  q2 :: Bool -> Bool -> Bool+  q2 True False = False+  q2 _    _     = True +Solution #5:+  q1 :: Bool -> Bool+  q1 True = True +  q1 _    = False++  q2 :: Bool -> Bool -> Bool+  q2 True False = False+  q2 _    _     = True +Solution #6:+  q1 :: Bool -> Bool+  q1 True = True +  q1 _    = False++  q2 :: Bool -> Bool -> Bool+  q2 False False = True +  q2 _     _     = False+Solution #7:+  q1 :: Bool -> Bool+  q1 True = True +  q1 _    = False++  q2 :: Bool -> Bool -> Bool+  q2 False False = True +  q2 True  True  = True +  q2 _     _     = False+Solution #8:+  q1 :: Bool -> Bool+  q1 _ = False++  q2 :: Bool -> Bool -> Bool+  q2 False False = True +  q2 True  True  = True +  q2 _     _     = False+Solution #9:+  q1 :: Bool -> Bool+  q1 True = False+  q1 _    = True ++  q2 :: Bool -> Bool -> Bool+  q2 False False = True +  q2 True  True  = True +  q2 _     _     = False+Solution #10:+  q1 :: Bool -> Bool+  q1 _ = False++  q2 :: Bool -> Bool -> Bool+  q2 False True = False+  q2 _     _    = True +Solution #11:+  q1 :: Bool -> Bool+  q1 True = False+  q1 _    = True ++  q2 :: Bool -> Bool -> Bool+  q2 False True = False+  q2 _     _    = True +Solution #12:+  q1 :: Bool -> Bool+  q1 _ = True++  q2 :: Bool -> Bool -> Bool+  q2 True  False = False+  q2 False True  = False+  q2 _     _     = True +Solution #13:+  q1 :: Bool -> Bool+  q1 _ = True++  q2 :: Bool -> Bool -> Bool+  q2 False True = False+  q2 _     _    = True +Solution #14:+  q1 :: Bool -> Bool+  q1 True = True +  q1 _    = False++  q2 :: Bool -> Bool -> Bool+  q2 False True = False+  q2 _     _    = True +Solution #15:+  q1 :: Bool -> Bool+  q1 True = True +  q1 _    = False++  q2 :: Bool -> Bool -> Bool+  q2 _ _ = True+Solution #16:+  q1 :: Bool -> Bool+  q1 True = False+  q1 _    = True ++  q2 :: Bool -> Bool -> Bool+  q2 _ _ = True+Solution #17:+  q1 :: Bool -> Bool+  q1 True = False+  q1 _    = True ++  q2 :: Bool -> Bool -> Bool+  q2 True False = False+  q2 _    _     = True +Solution #18:+  q1 :: Bool -> Bool+  q1 _ = True++  q2 :: Bool -> Bool -> Bool+  q2 True False = False+  q2 _    _     = True +Solution #19:+  q1 :: Bool -> Bool+  q1 _ = True++  q2 :: Bool -> Bool -> Bool+  q2 _ _ = True+Solution #20:+  q1 :: Bool -> Bool+  q1 True = False+  q1 _    = True ++  q2 :: Bool -> Bool -> Bool+  q2 _ _ = False+Solution #21:+  q1 :: Bool -> Bool+  q1 True = False+  q1 _    = True ++  q2 :: Bool -> Bool -> Bool+  q2 True False = True +  q2 _    _     = False+Solution #22:+  q1 :: Bool -> Bool+  q1 True = False+  q1 _    = True ++  q2 :: Bool -> Bool -> Bool+  q2 False True = True +  q2 _     _    = False+Solution #23:+  q1 :: Bool -> Bool+  q1 True = False+  q1 _    = True ++  q2 :: Bool -> Bool -> Bool+  q2 False False = False+  q2 _     _     = True +Solution #24:+  q1 :: Bool -> Bool+  q1 True = False+  q1 _    = True ++  q2 :: Bool -> Bool -> Bool+  q2 True  True  = False+  q2 False False = False+  q2 _     _     = True +Solution #25:+  q1 :: Bool -> Bool+  q1 True = False+  q1 _    = True ++  q2 :: Bool -> Bool -> Bool+  q2 True  False = False+  q2 False False = False+  q2 _     _     = True +Solution #26:+  q1 :: Bool -> Bool+  q1 True = False+  q1 _    = True ++  q2 :: Bool -> Bool -> Bool+  q2 True True = True +  q2 _    _    = False+Solution #27:+  q1 :: Bool -> Bool+  q1 _ = True++  q2 :: Bool -> Bool -> Bool+  q2 True True = True +  q2 _    _    = False+Solution #28:+  q1 :: Bool -> Bool+  q1 _ = True++  q2 :: Bool -> Bool -> Bool+  q2 True False = True +  q2 _    _     = False+Solution #29:+  q1 :: Bool -> Bool+  q1 _ = True++  q2 :: Bool -> Bool -> Bool+  q2 True False = True +  q2 True True  = True +  q2 _    _     = False+Solution #30:+  q1 :: Bool -> Bool+  q1 True = False+  q1 _    = True ++  q2 :: Bool -> Bool -> Bool+  q2 True False = True +  q2 True True  = True +  q2 _    _     = False+Solution #31:+  q1 :: Bool -> Bool+  q1 _ = True++  q2 :: Bool -> Bool -> Bool+  q2 False False = False+  q2 _     _     = True +Solution #32:+  q1 :: Bool -> Bool+  q1 _ = True++  q2 :: Bool -> Bool -> Bool+  q2 True  True  = False+  q2 False False = False+  q2 _     _     = True +Solution #33:+  q1 :: Bool -> Bool+  q1 True = True +  q1 _    = False++  q2 :: Bool -> Bool -> Bool+  q2 True False = True +  q2 _    _     = False+Solution #34:+  q1 :: Bool -> Bool+  q1 True = True +  q1 _    = False++  q2 :: Bool -> Bool -> Bool+  q2 False True  = True +  q2 True  False = True +  q2 _     _     = False+Solution #35:+  q1 :: Bool -> Bool+  q1 True = True +  q1 _    = False++  q2 :: Bool -> Bool -> Bool+  q2 False True  = False+  q2 False False = False+  q2 _     _     = True +Solution #36:+  q1 :: Bool -> Bool+  q1 True = True +  q1 _    = False++  q2 :: Bool -> Bool -> Bool+  q2 False False = False+  q2 _     _     = True +Solution #37:+  q1 :: Bool -> Bool+  q1 True = True +  q1 _    = False++  q2 :: Bool -> Bool -> Bool+  q2 True True = False+  q2 _    _    = True +Solution #38:+  q1 :: Bool -> Bool+  q1 True = True +  q1 _    = False++  q2 :: Bool -> Bool -> Bool+  q2 False True = False+  q2 True  True = False+  q2 _     _    = True +Solution #39:+  q1 :: Bool -> Bool+  q1 _ = True++  q2 :: Bool -> Bool -> Bool+  q2 False True = False+  q2 True  True = False+  q2 _     _    = True +Solution #40:+  q1 :: Bool -> Bool+  q1 _ = True++  q2 :: Bool -> Bool -> Bool+  q2 False False = True +  q2 _     _     = False+Solution #41:+  q1 :: Bool -> Bool+  q1 True = False+  q1 _    = True ++  q2 :: Bool -> Bool -> Bool+  q2 False False = True +  q2 _     _     = False+Solution #42:+  q1 :: Bool -> Bool+  q1 _ = False++  q2 :: Bool -> Bool -> Bool+  q2 False True = True +  q2 _     _    = False+Solution #43:+  q1 :: Bool -> Bool+  q1 _ = False++  q2 :: Bool -> Bool -> Bool+  q2 True True = True +  q2 _    _    = False+Solution #44:+  q1 :: Bool -> Bool+  q1 _ = True++  q2 :: Bool -> Bool -> Bool+  q2 False True = True +  q2 _     _    = False+Solution #45:+  q1 :: Bool -> Bool+  q1 _ = False++  q2 :: Bool -> Bool -> Bool+  q2 True False = True +  q2 _    _     = False+Solution #46:+  q1 :: Bool -> Bool+  q1 True = True +  q1 _    = False++  q2 :: Bool -> Bool -> Bool+  q2 _ _ = False+Solution #47:+  q1 :: Bool -> Bool+  q1 True = True +  q1 _    = False++  q2 :: Bool -> Bool -> Bool+  q2 True True = True +  q2 _    _    = False+Solution #48:+  q1 :: Bool -> Bool+  q1 _ = False++  q2 :: Bool -> Bool -> Bool+  q2 True False = True +  q2 True True  = True +  q2 _    _     = False+Solution #49:+  q1 :: Bool -> Bool+  q1 _ = False++  q2 :: Bool -> Bool -> Bool+  q2 False True = True +  q2 True  True = True +  q2 _     _    = False+Solution #50:+  q1 :: Bool -> Bool+  q1 True = True +  q1 _    = False++  q2 :: Bool -> Bool -> Bool+  q2 False True = True +  q2 _     _    = False+Solution #51:+  q1 :: Bool -> Bool+  q1 True = True +  q1 _    = False++  q2 :: Bool -> Bool -> Bool+  q2 False True = True +  q2 True  True = True +  q2 _     _    = False+Solution #52:+  q1 :: Bool -> Bool+  q1 _ = False++  q2 :: Bool -> Bool -> Bool+  q2 False True  = True +  q2 True  False = True +  q2 _     _     = False+Solution #53:+  q1 :: Bool -> Bool+  q1 _ = False++  q2 :: Bool -> Bool -> Bool+  q2 False False = False+  q2 _     _     = True +Solution #54:+  q1 :: Bool -> Bool+  q1 _ = True++  q2 :: Bool -> Bool -> Bool+  q2 True  False = False+  q2 False False = False+  q2 _     _     = True +Solution #55:+  q1 :: Bool -> Bool+  q1 True = True +  q1 _    = False++  q2 :: Bool -> Bool -> Bool+  q2 False False = True +  q2 False True  = True +  q2 _     _     = False+Solution #56:+  q1 :: Bool -> Bool+  q1 _ = True++  q2 :: Bool -> Bool -> Bool+  q2 True True = False+  q2 _    _    = True +Solution #57:+  q1 :: Bool -> Bool+  q1 _ = True++  q2 :: Bool -> Bool -> Bool+  q2 False False = True +  q2 False True  = True +  q2 _     _     = False+Solution #58:+  q1 :: Bool -> Bool+  q1 _ = False++  q2 :: Bool -> Bool -> Bool+  q2 True True = False+  q2 _    _    = True +Solution #59:+  q1 :: Bool -> Bool+  q1 True = False+  q1 _    = True ++  q2 :: Bool -> Bool -> Bool+  q2 True True = False+  q2 _    _    = True +Solution #60:+  q1 :: Bool -> Bool+  q1 True = False+  q1 _    = True ++  q2 :: Bool -> Bool -> Bool+  q2 False True = False+  q2 True  True = False+  q2 _     _    = True +Solution #61:+  q1 :: Bool -> Bool+  q1 True = False+  q1 _    = True ++  q2 :: Bool -> Bool -> Bool+  q2 False False = True +  q2 False True  = True +  q2 _     _     = False+Solution #62:+  q1 :: Bool -> Bool+  q1 _ = False++  q2 :: Bool -> Bool -> Bool+  q2 False False = True +  q2 _     _     = False+Solution #63:+  q1 :: Bool -> Bool+  q1 _ = False++  q2 :: Bool -> Bool -> Bool+  q2 False True = False+  q2 True  True = False+  q2 _     _    = True +Solution #64:+  q1 :: Bool -> Bool+  q1 _ = False++  q2 :: Bool -> Bool -> Bool+  q2 False False = True +  q2 False True  = True +  q2 _     _     = False Found 64 different solutions.
+ SBVTestSuite/GoldFiles/unint-axioms-query.gold view
@@ -0,0 +1,54 @@+** Calling: z3 -nw -in -smt2+[GOOD] ; Automatically generated by SBV. Do not edit.+[GOOD] (set-option :print-success true)+[GOOD] (set-option :global-declarations true)+[GOOD] (set-option :smtlib2_compliant true)+[GOOD] (set-option :diagnostic-output-channel "stdout")+[GOOD] (set-option :produce-models true)+[GOOD] (set-logic ALL) ; has user-defined sorts, using catch-all.+[GOOD] ; --- uninterpreted sorts ---+[GOOD] (declare-sort B 0)  ; N.B. Uninterpreted: B.B: not a nullary constructor+[GOOD] ; --- tuples ---+[GOOD] ; --- sums ---+[GOOD] ; --- literal constants ---+[GOOD] ; --- skolem constants ---+[GOOD] (declare-fun s0 () B) ; tracks user variable "p"+[GOOD] (declare-fun s1 () B) ; tracks user variable "q"+[GOOD] (declare-fun s2 () B) ; tracks user variable "r"+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (declare-fun AND (B B) B)+[GOOD] (declare-fun NOT (B) B)+[GOOD] (declare-fun OR (B B) B)+[GOOD] (define-fun s3 () B (AND s1 s2))+[GOOD] (define-fun s4 () B (OR s0 s3))+[GOOD] (define-fun s5 () B (NOT s4))+[GOOD] (define-fun s6 () B (NOT s0))+[GOOD] (define-fun s7 () B (NOT s1))+[GOOD] (define-fun s8 () B (AND s6 s7))+[GOOD] (define-fun s9 () B (NOT s2))+[GOOD] (define-fun s10 () B (AND s6 s9))+[GOOD] (define-fun s11 () B (OR s8 s10))+[GOOD] (define-fun s12 () Bool (distinct s5 s11))+[GOOD] (assert s12)+[GOOD] ; -- user given axiom: OR distributes over AND+[GOOD] (assert (forall ((p B) (q B) (r B))+          (= (AND (OR p q) (OR p r))+             (OR p (AND q r)))))+[GOOD] ; -- user given axiom: de Morgan+[GOOD] (assert (forall ((p B) (q B))+          (= (NOT (OR p q))+             (AND (NOT p) (NOT q)))))+[GOOD] ; -- user given axiom: double negation+[GOOD] (assert (forall ((p B)) (= (NOT (NOT p)) p)))+[SEND] (check-sat)+[RECV] unsat+*** Solver   : Z3+*** Exit code: ExitSuccess++ FINAL:Unsat+DONE!
SBVTestSuite/GoldFiles/validate_1.gold view
@@ -25,11 +25,11 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (s0))-[RECV] ((s0 (fp #b0 #xfe #b11111111111111111111111)))+[RECV] ((s0 (fp #b1 #xfe #b11111111111111111111111))) *** Solver   : Z3 *** Exit code: ExitSuccess [VALIDATE] Validating the model. Assignment:-[VALIDATE]       x = 3.4028235e38 :: Float+[VALIDATE]       x = -3.4028235e38 :: Float [VALIDATE] There are no constraints to check. [VALIDATE] Validating outputs. @@ -38,7 +38,7 @@ ***  *** Assignment: *** -***       x = 3.4028235e38 :: Float+***       x = -3.4028235e38 :: Float ***  *** Not all floating point operations are supported concretely. *** @@ -48,4 +48,4 @@ *** Alleged model: *** *** Satisfiable. Model:-***   x = 3.4028235e38 :: Float+***   x = -3.4028235e38 :: Float
SBVTestSuite/GoldFiles/validate_2.gold view
@@ -25,11 +25,11 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (s0))-[RECV] ((s0 (fp #b1 #x01 #b00000000000000000000000)))+[RECV] ((s0 (fp #b0 #x03 #b11011110110000010001000))) *** Solver   : Z3 *** Exit code: ExitSuccess [VALIDATE] Validating the model. Assignment:-[VALIDATE]       x = -1.1754944e-38 :: Float+[VALIDATE]       x = 8.793325e-38 :: Float [VALIDATE] There are no constraints to check. [VALIDATE] Validating outputs. @@ -38,7 +38,7 @@ ***  *** Assignment: *** -***       x = -1.1754944e-38 :: Float+***       x = 8.793325e-38 :: Float ***  *** Floating point FMA operation is not supported concretely. *** @@ -48,4 +48,4 @@ *** Alleged model: *** *** Satisfiable. Model:-***   x = -1.1754944e-38 :: Float+***   x = 8.793325e-38 :: Float
SBVTestSuite/TestSuite/Arrays/Query.hs view
@@ -29,6 +29,8 @@     , goldenCapturedIO "queryArrays4" $ t q4     , goldenCapturedIO "queryArrays5" $ t q5     , goldenCapturedIO "queryArrays6" $ t q6+    , goldenCapturedIO "queryArrays7" $ t q7+    , goldenCapturedIO "queryArrays8" $ t q8     ]     where t tc goldFile = do r <- runSMTWith defaultSMTCfg{verbose=True, redirectVerbose=Just goldFile} tc                              appendFile goldFile ("\n FINAL:" ++ show r ++ "\nDONE!\n")@@ -118,5 +120,34 @@                                         constrain $ d .>= 1 .&& d .< 3                                         loop (writeArray a 1 (readArray a 1 + d)) (sofar ++ [d])                             Sat   -> mapM getValue sofar+++q7 :: Symbolic (CheckSatResult, CheckSatResult)+q7 = do x :: SArray Integer Integer <- newArray "x" Nothing+        let y = writeArray x 0 1++        query $ do constrain $ readArray y 0 .== 2+                   r1 <- checkSat++                   resetAssertions++                   constrain $ readArray y 0 .== 2+                   r2 <- checkSat++                   pure (r1, r2)++q8 :: Symbolic (CheckSatResult, CheckSatResult)+q8 = query $ do x :: SArray Integer Integer <- freshArray "x" Nothing+                let y = writeArray x 0 1++                constrain $ readArray y 0 .== 2+                r1 <- checkSat++                resetAssertions++                constrain $ readArray y 0 .== 2+                r2 <- checkSat++                pure (r1, r2)  {-# ANN module ("HLint: ignore Reduce duplication" :: String) #-}
SBVTestSuite/TestSuite/Basics/Tuple.hs view
@@ -52,6 +52,10 @@   [abx, bay] <- sTuples @(Integer, Integer, Integer) ["abx", "bay"]   constrain $ abx^._1 .== bay^._2   constrain $ abx^._2 .== bay^._1+  constrain $ abx^._1 .== 1+  constrain $ abx^._2 .== 2+  constrain $ abx^._3 .== 3+  constrain $ bay^._3 .== 4   query $ do _ <- checkSat              (,) <$> getValue abx <*> getValue bay @@ -138,4 +142,5 @@                 Unsat -> return ()                 _     -> error "did not expect this!" -{-# ANN module ("HLint: ignore Use ." :: String) #-}+{-# ANN module ("HLint: ignore Use ."        :: String) #-}+{-# ANN module ("HLint: ignore Redundant ^." :: String) #-}
SBVTestSuite/TestSuite/Queries/Tuples.hs view
@@ -64,4 +64,5 @@        then return av        else error $ "Didn't expect this: " ++ show av -{-# ANN module ("HLint: ignore Use ." :: String) #-}+{-# ANN module ("HLint: ignore Use ."        :: String) #-}+{-# ANN module ("HLint: ignore Redundant ^." :: String) #-}
SBVTestSuite/TestSuite/Queries/Uninterpreted.hs view
@@ -38,7 +38,6 @@  instance SymVal L instance HasKind L-instance SMTValue L  unint1 :: Symbolic String unint1 = do (x :: SBV L) <- free_
SBVTestSuite/TestSuite/Uninterpreted/Axioms.hs view
@@ -19,10 +19,14 @@ import Utils.SBVTestFramework import Data.Generics +import Data.SBV.Control+ tests :: TestTree tests =   testGroup "Uninterpreted.Axioms"-    [ testCase "unint-axioms" (assertIsThm p0) ]+    [ testCase         "unint-axioms"       (assertIsThm p0)+    , goldenCapturedIO "unint-axioms-query" testQuery+    ]  -- Example provided by Thomas DuBuisson: newtype Bitstring = Bitstring () deriving (Eq, Ord, Show, Read, Data, SymVal, HasKind)@@ -47,3 +51,29 @@     constrain $ a p     constrain $ a k     return $ a (e k p)++newtype B = B () deriving (Eq, Ord, Show, Read, Data, SymVal, HasKind)+type SB = SBV B++testQuery :: FilePath -> IO ()+testQuery rf = do r <- runSMTWith defaultSMTCfg{verbose=True, redirectVerbose=Just rf} t+                  appendFile rf ("\n FINAL:" ++ show r ++ "\nDONE!\n")+ where t = do p <- free "p"+              q <- free "q"+              r <- free "r"+              query $ do let oR, aND :: SB  -> SB -> SB+                             oR  = uninterpret "OR"+                             aND = uninterpret "AND"+                             nOT :: SB -> SB+                             nOT = uninterpret "NOT"+                         constrain $ nOT (p `oR` (q `aND` r)) ./= (nOT p `aND` nOT q) `oR` (nOT p `aND` nOT r)+                         addAxiom "OR distributes over AND" [ "(assert (forall ((p B) (q B) (r B))"+                                                            , "   (= (AND (OR p q) (OR p r))"+                                                            , "      (OR p (AND q r)))))"+                                                            ]+                         addAxiom "de Morgan"               [ "(assert (forall ((p B) (q B))"+                                                            , "   (= (NOT (OR p q))"+                                                            , "      (AND (NOT p) (NOT q)))))"+                                                            ]+                         addAxiom "double negation"         ["(assert (forall ((p B)) (= (NOT (NOT p)) p)))"]+                         checkSat
SBVTestSuite/Utils/SBVTestFramework.hs view
@@ -36,7 +36,6 @@ import Control.Monad.Trans (liftIO)  import qualified Data.ByteString.Lazy.Char8 as LBC-import qualified Data.ByteString as BS  import System.Directory   (removeFile) import System.Environment (lookupEnv)@@ -44,8 +43,7 @@ import Test.Tasty            (testGroup, TestTree, TestName) import Test.Tasty.HUnit      ((@?), Assertion, testCase, AssertionPredicable) -import Test.Tasty.Golden           (goldenVsString)-import Test.Tasty.Golden.Advanced  (goldenTest)+import Test.Tasty.Golden     (goldenVsString, goldenVsFileDiff)  import qualified Test.Tasty.QuickCheck   as QC import qualified Test.QuickCheck.Monadic as QC@@ -56,7 +54,7 @@ import Data.SBV import Data.SBV.Control -import Data.Char  (chr, ord, isDigit)+import Data.Char  (isDigit) import Data.Maybe (fromMaybe, catMaybes)  import System.FilePath ((</>), (<.>))@@ -114,53 +112,12 @@ goldenVsStringShow n res = goldenVsString n (goldFile n) (fmap (LBC.pack . show) res)  goldenCapturedIO :: TestName -> (FilePath -> IO ()) -> TestTree-goldenCapturedIO n res = doTheDiff n gf gfTmp (rm gfTmp >> res gfTmp)+goldenCapturedIO n res = goldenVsFileDiff n diff gf gfTmp (rm gfTmp >> res gfTmp)   where gf    = goldFile n         gfTmp = gf ++ "_temp"--        rm f = removeFile f `C.catch` (\(_ :: C.SomeException) -> return ())---- | When comparing ignore \r's for windows's sake-doTheDiff :: TestName -> FilePath -> FilePath -> IO () -> TestTree-doTheDiff nm ref new act = goldenTest nm (BS.readFile ref) (act >> BS.readFile new) cmp upd-   where upd = BS.writeFile ref--         cmp :: BS.ByteString -> BS.ByteString -> IO (Maybe String)-         cmp x y-          | cleanUp x == cleanUp y = return Nothing-          | True                   = return $ Just $ unlines $ [ "Discrepancy found. Expected: " ++ ref-                                                               , "============================================"-                                                               ]-                                                            ++ lxs-                                                            ++ [ "Got: " ++ new-                                                               , "============================================"-                                                               ]-                                                            ++ lys-                                                            ++ [ "Diff: "-                                                               , "============================================"-                                                               ]-                                                            ++ diff-          where xs = map (chr . fromIntegral) $ BS.unpack x-                ys = map (chr . fromIntegral) $ BS.unpack y--                lxs = lines xs-                lys = lines ys--                diffLen = length lxs `max` length lys-                diff    = concatMap pick $ zip3 [1..diffLen] (lxs ++ repeat "") (lys ++ repeat "")--                pick (i, expected, got)-                  | filter (/= '\r') expected == filter (/= '\r') got-                  = []-                  | True-                  = [ "== Line " ++ show i ++ " =="-                    , "  Expected: " ++ show expected-                    , "  Got     : " ++ show got-                    ]+        rm f  = removeFile f `C.catch` (\(_ :: C.SomeException) -> return ()) -         -- deal with insane Windows \r stuff-         cleanUp = BS.filter (/= slashr)-         slashr  = fromIntegral (ord '\r')+        diff ref new = ["diff", "-u", ref, new]  -- | Count the number of models. It's not kosher to -- call this function if you provided a max-model count@@ -195,7 +152,7 @@ assertIsntSat p = assert (fmap not (isSatisfiable p))  -- | Quick-check a unary function, creating one version for constant folding, and another for solver-qc1 :: (Eq a, SymVal a, SymVal b, Show a, QC.Arbitrary a, Eq b, SMTValue b) => String -> (a -> b) -> (SBV a -> SBV b) -> [TestTree]+qc1 :: (Eq a, SymVal a, SymVal b, Show a, QC.Arbitrary a, Eq b) => String -> (a -> b) -> (SBV a -> SBV b) -> [TestTree] qc1 nm opC opS = [cf, sm]    where cf = QC.testProperty (nm ++ ".constantFold") $ do                         i <- free "i"@@ -247,7 +204,7 @@   -- | Quick-check a binary function, creating one version for constant folding, and another for solver-qc2 :: (Eq a, Eq b, SymVal a, SymVal b, SymVal c, Show a, Show b, QC.Arbitrary a, QC.Arbitrary b, Eq c, SMTValue c) => String -> (a -> b -> c) -> (SBV a -> SBV b -> SBV c) -> [TestTree]+qc2 :: (Eq a, Eq b, SymVal a, SymVal b, SymVal c, Show a, Show b, QC.Arbitrary a, QC.Arbitrary b, Eq c) => String -> (a -> b -> c) -> (SBV a -> SBV b -> SBV c) -> [TestTree] qc2 nm opC opS = [cf, sm]    where cf = QC.testProperty (nm ++ ".constantFold") $ do                         i1 <- free "i1"
sbv.cabal view
@@ -1,5 +1,5 @@ Name:          sbv-Version:       8.6+Version:       8.7 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@@ -72,7 +72,7 @@                     ViewPatterns   Build-Depends   : base >= 4.11 && < 5                   , crackNum >= 2.3-                  , ghc, QuickCheck, template-haskell+                  , QuickCheck, template-haskell                   , array, async, containers, deepseq, directory, filepath, time                   , pretty, process, mtl, random, syb, transformers                   , generic-deriving@@ -126,6 +126,7 @@                   , Documentation.SBV.Examples.Misc.ModelExtract                   , Documentation.SBV.Examples.Misc.Auxiliary                   , Documentation.SBV.Examples.Misc.NoDiv0+                  , Documentation.SBV.Examples.Misc.Newtypes                   , Documentation.SBV.Examples.Misc.Polynomials                   , Documentation.SBV.Examples.Misc.SetAlgebra                   , Documentation.SBV.Examples.Misc.SoftConstrain@@ -140,6 +141,7 @@                   , Documentation.SBV.Examples.ProofTools.Strengthen                   , Documentation.SBV.Examples.ProofTools.Sum                   , Documentation.SBV.Examples.WeakestPreconditions.Append+                  , Documentation.SBV.Examples.WeakestPreconditions.Basics                   , Documentation.SBV.Examples.WeakestPreconditions.Fib                   , Documentation.SBV.Examples.WeakestPreconditions.GCD                   , Documentation.SBV.Examples.WeakestPreconditions.IntDiv@@ -167,6 +169,7 @@                   , Documentation.SBV.Examples.Queries.CaseSplit                   , Documentation.SBV.Examples.Queries.Enums                   , Documentation.SBV.Examples.Queries.Interpolants+                  , Documentation.SBV.Examples.Queries.Concurrency                   , Documentation.SBV.Examples.Strings.RegexCrossword                   , Documentation.SBV.Examples.Strings.SQLInjection                   , Documentation.SBV.Examples.Transformers.SymbolicEval@@ -410,11 +413,11 @@                     TypeApplications   Build-depends : base >= 4.11, filepath, syb, crackNum >= 2.3                 , sbv, directory, random, mtl, containers-                , criterion, process, deepseq+                , gauge, process, deepseq, silently   Hs-Source-Dirs  : SBVBenchSuite   main-is         : SBVBench.hs   Other-modules   : Utils.SBVBenchFramework-                  , BenchSuite.Overhead.SBVOverhead+                  , BenchSuite.Bench.Bench                   , BenchSuite.Puzzles.Birthday                   , BenchSuite.Puzzles.Coins                   , BenchSuite.Puzzles.Counts@@ -427,3 +430,70 @@                   , BenchSuite.Puzzles.SendMoreMoney                   , BenchSuite.Puzzles.Sudoku                   , BenchSuite.Puzzles.U2Bridge+                  , BenchSuite.BitPrecise.BitTricks+                  , BenchSuite.BitPrecise.BrokenSearch+                  , BenchSuite.BitPrecise.Legato+                  , BenchSuite.BitPrecise.MergeSort+                  , BenchSuite.BitPrecise.MultMask+                  , BenchSuite.BitPrecise.PrefixSum+                  , BenchSuite.Queries.AllSat+                  , BenchSuite.Queries.CaseSplit+                  , BenchSuite.Queries.Concurrency+                  , BenchSuite.Queries.Enums+                  , BenchSuite.Queries.FourFours+                  , BenchSuite.Queries.GuessNumber+                  , BenchSuite.Queries.Interpolants+                  , BenchSuite.Queries.UnsatCore+                  , BenchSuite.WeakestPreconditions.Instances+                  , BenchSuite.WeakestPreconditions.Append+                  , BenchSuite.WeakestPreconditions.Basics+                  , BenchSuite.WeakestPreconditions.Fib+                  , BenchSuite.WeakestPreconditions.GCD+                  , BenchSuite.WeakestPreconditions.IntDiv+                  , BenchSuite.WeakestPreconditions.IntSqrt+                  , BenchSuite.WeakestPreconditions.Length+                  , BenchSuite.WeakestPreconditions.Sum+                  , BenchSuite.Optimization.Instances+                  , BenchSuite.Optimization.Enumerate+                  , BenchSuite.Optimization.ExtField+                  , BenchSuite.Optimization.LinearOpt+                  , BenchSuite.Optimization.Production+                  , BenchSuite.Optimization.VM+                  , BenchSuite.Uninterpreted.AUF+                  , BenchSuite.Uninterpreted.Deduce+                  , BenchSuite.Uninterpreted.Function+                  , BenchSuite.Uninterpreted.Multiply+                  , BenchSuite.Uninterpreted.Shannon+                  , BenchSuite.Uninterpreted.Sort+                  , BenchSuite.Uninterpreted.UISortAllSat+                  , BenchSuite.ProofTools.BMC+                  , BenchSuite.ProofTools.Fibonacci+                  , BenchSuite.ProofTools.Strengthen+                  , BenchSuite.ProofTools.Sum+                  , BenchSuite.CodeGeneration.AddSub+                  , BenchSuite.CodeGeneration.CRC_USB5+                  , BenchSuite.CodeGeneration.Fibonacci+                  , BenchSuite.CodeGeneration.GCD+                  , BenchSuite.CodeGeneration.PopulationCount+                  , BenchSuite.CodeGeneration.Uninterpreted+                  , BenchSuite.Crypto.AES+                  , BenchSuite.Crypto.RC4+                  , BenchSuite.Crypto.SHA+                  , BenchSuite.Misc.Auxiliary+                  , BenchSuite.Misc.Enumerate+                  , BenchSuite.Misc.Floating+                  , BenchSuite.Misc.ModelExtract+                  , BenchSuite.Misc.Newtypes+                  , BenchSuite.Misc.NoDiv0+                  , BenchSuite.Misc.Polynomials+                  , BenchSuite.Misc.SetAlgebra+                  , BenchSuite.Misc.SoftConstrain+                  , BenchSuite.Misc.Tuple+                  , BenchSuite.Lists.BoundedMutex+                  , BenchSuite.Lists.Fibonacci+                  , BenchSuite.Lists.Nested+                  , BenchSuite.Strings.RegexCrossword+                  , BenchSuite.Strings.SQLInjection+                  , BenchSuite.Existentials.CRCPolynomial+                  , BenchSuite.Existentials.Diophantine+                  , BenchSuite.Transformers.SymbolicEval